# 1 "/home/preben/working/CRTPlanner/CRTPlanner.cpp"
# 1 "/home/preben/working/CRTPlanner/build/Debug//"
# 1 "<built-in>"
#define __STDC__ 1
#define __cplusplus 1
#define __STDC_HOSTED__ 1
#define __GNUC__ 4
#define __GNUC_MINOR__ 4
#define __GNUC_PATCHLEVEL__ 3
#define __GNUG__ 4
#define __SIZE_TYPE__ long unsigned int
#define __PTRDIFF_TYPE__ long int
#define __WCHAR_TYPE__ int
#define __WINT_TYPE__ unsigned int
#define __INTMAX_TYPE__ long int
#define __UINTMAX_TYPE__ long unsigned int
#define __CHAR16_TYPE__ short unsigned int
#define __CHAR32_TYPE__ unsigned int
#define __GXX_WEAK__ 1
#define __DEPRECATED 1
#define __GXX_RTTI 1
#define __EXCEPTIONS 1
#define __GXX_ABI_VERSION 1002
#define __SCHAR_MAX__ 127
#define __SHRT_MAX__ 32767
#define __INT_MAX__ 2147483647
#define __LONG_MAX__ 9223372036854775807L
#define __LONG_LONG_MAX__ 9223372036854775807LL
#define __WCHAR_MAX__ 2147483647
#define __CHAR_BIT__ 8
#define __INTMAX_MAX__ 9223372036854775807L
#define __FLT_EVAL_METHOD__ 0
#define __DEC_EVAL_METHOD__ 2
#define __FLT_RADIX__ 2
#define __FLT_MANT_DIG__ 24
#define __FLT_DIG__ 6
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX_10_EXP__ 38
#define __FLT_MAX__ 3.40282347e+38F
#define __FLT_MIN__ 1.17549435e-38F
#define __FLT_EPSILON__ 1.19209290e-7F
#define __FLT_DENORM_MIN__ 1.40129846e-45F
#define __FLT_HAS_DENORM__ 1
#define __FLT_HAS_INFINITY__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __DBL_MANT_DIG__ 53
#define __DBL_DIG__ 15
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX_10_EXP__ 308
#define __DBL_MAX__ 1.7976931348623157e+308
#define __DBL_MIN__ 2.2250738585072014e-308
#define __DBL_EPSILON__ 2.2204460492503131e-16
#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
#define __DBL_HAS_DENORM__ 1
#define __DBL_HAS_INFINITY__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __LDBL_MANT_DIG__ 64
#define __LDBL_DIG__ 18
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX_10_EXP__ 4932
#define __DECIMAL_DIG__ 21
#define __LDBL_MAX__ 1.18973149535723176502e+4932L
#define __LDBL_MIN__ 3.36210314311209350626e-4932L
#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
#define __LDBL_HAS_DENORM__ 1
#define __LDBL_HAS_INFINITY__ 1
#define __LDBL_HAS_QUIET_NAN__ 1
#define __DEC32_MANT_DIG__ 7
#define __DEC32_MIN_EXP__ (-94)
#define __DEC32_MAX_EXP__ 97
#define __DEC32_MIN__ 1E-95DF
#define __DEC32_MAX__ 9.999999E96DF
#define __DEC32_EPSILON__ 1E-6DF
#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
#define __DEC64_MANT_DIG__ 16
#define __DEC64_MIN_EXP__ (-382)
#define __DEC64_MAX_EXP__ 385
#define __DEC64_MIN__ 1E-383DD
#define __DEC64_MAX__ 9.999999999999999E384DD
#define __DEC64_EPSILON__ 1E-15DD
#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
#define __DEC128_MANT_DIG__ 34
#define __DEC128_MIN_EXP__ (-6142)
#define __DEC128_MAX_EXP__ 6145
#define __DEC128_MIN__ 1E-6143DL
#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
#define __DEC128_EPSILON__ 1E-33DL
#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
#define __REGISTER_PREFIX__ 
#define __USER_LABEL_PREFIX__ 
#define __VERSION__ "4.4.3"
#define __GNUC_GNU_INLINE__ 1
#define _LP64 1
#define __LP64__ 1
#define __NO_INLINE__ 1
#define __FINITE_MATH_ONLY__ 0
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
#define __GCC_HAVE_DWARF2_CFI_ASM 1
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_SIZE_T__ 8
#define __SIZEOF_WCHAR_T__ 4
#define __SIZEOF_WINT_T__ 4
#define __SIZEOF_PTRDIFF_T__ 8
#define __SIZEOF_POINTER__ 8
#define __amd64 1
#define __amd64__ 1
#define __x86_64 1
#define __x86_64__ 1
#define __k8 1
#define __k8__ 1
#define __MMX__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __SSE_MATH__ 1
#define __SSE2_MATH__ 1
#define __gnu_linux__ 1
#define __linux 1
#define __linux__ 1
#define linux 1
#define __unix 1
#define __unix__ 1
#define unix 1
#define __ELF__ 1
#define __DECIMAL_BID_FORMAT__ 1
#define __BIGGEST_ALIGNMENT__ 16
# 1 "<command-line>"
#define _GNU_SOURCE 1
#define RW_ENABLE_ASSERT 1
#define _FORTIFY_SOURCE 2
# 1 "/home/preben/working/CRTPlanner/CRTPlanner.cpp"
# 10 "/home/preben/working/CRTPlanner/CRTPlanner.cpp"
# 1 "/home/preben/working/CRTPlanner/CRTPlanner.hpp" 1
# 9 "/home/preben/working/CRTPlanner/CRTPlanner.hpp"
#define CRTPLANNER_HPP_ 



# 1 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 1
# 9 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp"
#define RW_DYNAMICS_DYNAMICWORKCELL_HPP_ 



# 1 "/home/preben/working/CRTPlanner/MechSystem.hpp" 1

#define MECH_SYSTEM_HPP_ 



# 1 "/home/preben/working/CRTPlanner/Constraint.hpp" 1

#define CONSTRAINT_HPP_ 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
#define _GLIBCXX_OSTREAM 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 3
#define _GLIBCXX_IOS 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 3
#define _GLIBCXX_IOSFWD 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_CXX_CONFIG_H 1


#define __GLIBCXX__ 20100121




#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1


#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V)))
# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_DEPRECATED 1





#define _GLIBCXX_DEPRECATED_ATTR 
# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION 0
# 109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_STD_D _GLIBCXX_STD
#define _GLIBCXX_STD_P _GLIBCXX_STD
#define _GLIBCXX_STD std
#define _GLIBCXX_BEGIN_NESTED_NAMESPACE(X,Y) _GLIBCXX_BEGIN_NAMESPACE(X)
#define _GLIBCXX_END_NESTED_NAMESPACE _GLIBCXX_END_NAMESPACE
#define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
#define _GLIBCXX_END_NAMESPACE }
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
# 220 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_LDBL_NAMESPACE 
#define _GLIBCXX_BEGIN_LDBL_NAMESPACE 
#define _GLIBCXX_END_LDBL_NAMESPACE 





#define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
#define _GLIBCXX_END_EXTERN_C }
# 243 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/os_defines.h" 3
#define _GLIBCXX_OS_DEFINES 1





#define __NO_CTYPE 1

# 1 "/usr/include/features.h" 1 3 4
# 20 "/usr/include/features.h" 3 4
#define _FEATURES_H 1
# 95 "/usr/include/features.h" 3 4
#undef __USE_ISOC99
#undef __USE_ISOC95
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
#undef __USE_POSIX199506
#undef __USE_XOPEN
#undef __USE_XOPEN_EXTENDED
#undef __USE_UNIX98
#undef __USE_XOPEN2K
#undef __USE_XOPEN2K8
#undef __USE_LARGEFILE
#undef __USE_LARGEFILE64
#undef __USE_FILE_OFFSET64
#undef __USE_BSD
#undef __USE_SVID
#undef __USE_MISC
#undef __USE_ATFILE
#undef __USE_GNU
#undef __USE_REENTRANT
#undef __USE_FORTIFY_LEVEL
#undef __FAVOR_BSD
#undef __KERNEL_STRICT_NAMES




#define __KERNEL_STRICT_NAMES 



#define __USE_ANSI 1
# 136 "/usr/include/features.h" 3 4
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
# 153 "/usr/include/features.h" 3 4
#undef _ISOC99_SOURCE
#define _ISOC99_SOURCE 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#undef _XOPEN_SOURCE_EXTENDED
#define _XOPEN_SOURCE_EXTENDED 1
#undef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
# 189 "/usr/include/features.h" 3 4
#define __USE_ISOC99 1





#define __USE_ISOC95 1
# 216 "/usr/include/features.h" 3 4
#define __USE_POSIX 1



#define __USE_POSIX2 1



#define __USE_POSIX199309 1



#define __USE_POSIX199506 1



#define __USE_XOPEN2K 1
#undef __USE_ISOC99
#define __USE_ISOC99 1



#define __USE_XOPEN2K8 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1



#define __USE_XOPEN 1

#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1
#undef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE 1


#define __USE_XOPEN2K8 1

#define __USE_XOPEN2K 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
# 266 "/usr/include/features.h" 3 4
#define __USE_LARGEFILE 1



#define __USE_LARGEFILE64 1







#define __USE_MISC 1



#define __USE_BSD 1



#define __USE_SVID 1



#define __USE_ATFILE 1



#define __USE_GNU 1
# 309 "/usr/include/features.h" 3 4
#define __USE_FORTIFY_LEVEL 0



#define __STDC_IEC_559__ 1
#define __STDC_IEC_559_COMPLEX__ 1


#define __STDC_ISO_10646__ 200009L







#undef __GNU_LIBRARY__
#define __GNU_LIBRARY__ 6



#define __GLIBC__ 2
#define __GLIBC_MINOR__ 11

#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))







#define __GLIBC_HAVE_LONG_LONG 1





# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 21 "/usr/include/sys/cdefs.h" 3 4
#define _SYS_CDEFS_H 1
# 36 "/usr/include/sys/cdefs.h" 3 4
#undef __P
#undef __PMT
# 51 "/usr/include/sys/cdefs.h" 3 4
#define __THROW throw ()
#define __NTH(fct) fct throw ()
# 74 "/usr/include/sys/cdefs.h" 3 4
#define __P(args) args
#define __PMT(args) args




#define __CONCAT(x,y) x ## y
#define __STRING(x) #x


#define __ptr_t void *
#define __long_double_t long double




#define __BEGIN_DECLS extern "C" {
#define __END_DECLS }
# 114 "/usr/include/sys/cdefs.h" 3 4
#define __BEGIN_NAMESPACE_STD 
#define __END_NAMESPACE_STD 
#define __USING_NAMESPACE_STD(name) 
#define __BEGIN_NAMESPACE_C99 
#define __END_NAMESPACE_C99 
#define __USING_NAMESPACE_C99(name) 





#define __bounded 
#define __unbounded 
#define __ptrvalue 




#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
#define __bos0(ptr) __builtin_object_size (ptr, 0)


#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg)))

#define __warnattr(msg) __attribute__((__warning__ (msg)))
#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg)))
# 150 "/usr/include/sys/cdefs.h" 3 4
#define __flexarr []
# 177 "/usr/include/sys/cdefs.h" 3 4
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))

#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias))





#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
# 207 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_malloc__ __attribute__ ((__malloc__))
# 216 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_pure__ __attribute__ ((__pure__))
# 225 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))







#define __attribute_deprecated__ __attribute__ ((__deprecated__))
# 246 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
# 256 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
# 265 "/usr/include/sys/cdefs.h" 3 4
#define __nonnull(params) __attribute__ ((__nonnull__ params))







#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__))
# 282 "/usr/include/sys/cdefs.h" 3 4
#define __wur 




#define __always_inline __inline __attribute__ ((__always_inline__))
# 296 "/usr/include/sys/cdefs.h" 3 4
#define __extern_inline extern __inline __attribute__ ((__gnu_inline__))

#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__, __artificial__))
# 318 "/usr/include/sys/cdefs.h" 3 4
#define __va_arg_pack() __builtin_va_arg_pack ()
#define __va_arg_pack_len() __builtin_va_arg_pack_len ()
# 342 "/usr/include/sys/cdefs.h" 3 4
#define __restrict_arr 
# 353 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 354 "/usr/include/sys/cdefs.h" 2 3 4
# 375 "/usr/include/sys/cdefs.h" 3 4
#define __LDBL_REDIR1(name,proto,alias) name proto
#define __LDBL_REDIR(name,proto) name proto
#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW
#define __LDBL_REDIR_NTH(name,proto) name proto __THROW
#define __LDBL_REDIR_DECL(name) 

#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias)
#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias)
# 348 "/usr/include/features.h" 2 3 4
# 371 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4



# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 5 "/usr/include/gnu/stubs.h" 2 3 4




# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 10 "/usr/include/gnu/stubs-64.h" 3 4
#define __stub_bdflush 
#define __stub_chflags 
#define __stub_fattach 
#define __stub_fchflags 
#define __stub_fdetach 
#define __stub_getmsg 
#define __stub_gtty 
#define __stub_lchmod 
#define __stub_putmsg 
#define __stub_revoke 
#define __stub_setlogin 
#define __stub_sigreturn 
#define __stub_sstk 
#define __stub_stty 
# 10 "/usr/include/gnu/stubs.h" 2 3 4
# 372 "/usr/include/features.h" 2 3 4
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/cpu_defines.h" 3
#define _GLIBCXX_CPU_DEFINES 1
# 247 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
# 259 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_EXTERN_TEMPLATE 1






#define _GLIBCXX_WEAK_DEFINITION 






#define __glibcxx_assert(_Condition) 
# 304 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_FAST_MATH 0






#define __N(msgid) (msgid)


#undef min
#undef max






#define _GLIBCXX_HAVE_ACOSF 1


#define _GLIBCXX_HAVE_ACOSL 1


#define _GLIBCXX_HAVE_ASINF 1


#define _GLIBCXX_HAVE_ASINL 1


#define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1


#define _GLIBCXX_HAVE_ATAN2F 1


#define _GLIBCXX_HAVE_ATAN2L 1


#define _GLIBCXX_HAVE_ATANF 1


#define _GLIBCXX_HAVE_ATANL 1





#define _GLIBCXX_HAVE_CEILF 1


#define _GLIBCXX_HAVE_CEILL 1


#define _GLIBCXX_HAVE_COMPLEX_H 1


#define _GLIBCXX_HAVE_COSF 1


#define _GLIBCXX_HAVE_COSHF 1


#define _GLIBCXX_HAVE_COSHL 1


#define _GLIBCXX_HAVE_COSL 1


#define _GLIBCXX_HAVE_DLFCN_H 1


#define _GLIBCXX_HAVE_EBADMSG 1


#define _GLIBCXX_HAVE_ECANCELED 1


#define _GLIBCXX_HAVE_EIDRM 1


#define _GLIBCXX_HAVE_ENDIAN_H 1


#define _GLIBCXX_HAVE_ENODATA 1


#define _GLIBCXX_HAVE_ENOLINK 1


#define _GLIBCXX_HAVE_ENOSR 1


#define _GLIBCXX_HAVE_ENOSTR 1


#define _GLIBCXX_HAVE_ENOTRECOVERABLE 1


#define _GLIBCXX_HAVE_ENOTSUP 1


#define _GLIBCXX_HAVE_EOVERFLOW 1


#define _GLIBCXX_HAVE_EOWNERDEAD 1


#define _GLIBCXX_HAVE_EPROTO 1


#define _GLIBCXX_HAVE_ETIME 1


#define _GLIBCXX_HAVE_ETXTBSY 1


#define _GLIBCXX_HAVE_EXPF 1


#define _GLIBCXX_HAVE_EXPL 1


#define _GLIBCXX_HAVE_FABSF 1


#define _GLIBCXX_HAVE_FABSL 1


#define _GLIBCXX_HAVE_FENV_H 1


#define _GLIBCXX_HAVE_FINITE 1


#define _GLIBCXX_HAVE_FINITEF 1


#define _GLIBCXX_HAVE_FINITEL 1


#define _GLIBCXX_HAVE_FLOAT_H 1


#define _GLIBCXX_HAVE_FLOORF 1


#define _GLIBCXX_HAVE_FLOORL 1


#define _GLIBCXX_HAVE_FMODF 1


#define _GLIBCXX_HAVE_FMODL 1
# 466 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_HAVE_FREXPF 1


#define _GLIBCXX_HAVE_FREXPL 1


#define _GLIBCXX_HAVE_GETIPINFO 1



#define _GLIBCXX_HAVE_GTHR_DEFAULT 1


#define _GLIBCXX_HAVE_HYPOT 1


#define _GLIBCXX_HAVE_HYPOTF 1


#define _GLIBCXX_HAVE_HYPOTL 1


#define _GLIBCXX_HAVE_ICONV 1





#define _GLIBCXX_HAVE_INT64_T 1


#define _GLIBCXX_HAVE_INT64_T_LONG 1





#define _GLIBCXX_HAVE_INTTYPES_H 1


#define _GLIBCXX_HAVE_ISINF 1


#define _GLIBCXX_HAVE_ISINFF 1


#define _GLIBCXX_HAVE_ISINFL 1


#define _GLIBCXX_HAVE_ISNAN 1


#define _GLIBCXX_HAVE_ISNANF 1


#define _GLIBCXX_HAVE_ISNANL 1


#define _GLIBCXX_HAVE_ISWBLANK 1


#define _GLIBCXX_HAVE_LC_MESSAGES 1


#define _GLIBCXX_HAVE_LDEXPF 1


#define _GLIBCXX_HAVE_LDEXPL 1


#define _GLIBCXX_HAVE_LIBINTL_H 1


#define _GLIBCXX_HAVE_LIMIT_AS 1


#define _GLIBCXX_HAVE_LIMIT_DATA 1


#define _GLIBCXX_HAVE_LIMIT_FSIZE 1


#define _GLIBCXX_HAVE_LIMIT_RSS 1


#define _GLIBCXX_HAVE_LIMIT_VMEM 0


#define _GLIBCXX_HAVE_LINUX_FUTEX 1


#define _GLIBCXX_HAVE_LOCALE_H 1


#define _GLIBCXX_HAVE_LOG10F 1


#define _GLIBCXX_HAVE_LOG10L 1


#define _GLIBCXX_HAVE_LOGF 1


#define _GLIBCXX_HAVE_LOGL 1
# 578 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_HAVE_MBSTATE_T 1


#define _GLIBCXX_HAVE_MEMORY_H 1


#define _GLIBCXX_HAVE_MODF 1


#define _GLIBCXX_HAVE_MODFF 1


#define _GLIBCXX_HAVE_MODFL 1





#define _GLIBCXX_HAVE_POLL 1


#define _GLIBCXX_HAVE_POWF 1


#define _GLIBCXX_HAVE_POWL 1





#define _GLIBCXX_HAVE_SETENV 1


#define _GLIBCXX_HAVE_SINCOS 1


#define _GLIBCXX_HAVE_SINCOSF 1


#define _GLIBCXX_HAVE_SINCOSL 1


#define _GLIBCXX_HAVE_SINF 1


#define _GLIBCXX_HAVE_SINHF 1


#define _GLIBCXX_HAVE_SINHL 1


#define _GLIBCXX_HAVE_SINL 1


#define _GLIBCXX_HAVE_SQRTF 1


#define _GLIBCXX_HAVE_SQRTL 1


#define _GLIBCXX_HAVE_STDBOOL_H 1


#define _GLIBCXX_HAVE_STDINT_H 1


#define _GLIBCXX_HAVE_STDLIB_H 1


#define _GLIBCXX_HAVE_STRERROR_L 1


#define _GLIBCXX_HAVE_STRERROR_R 1


#define _GLIBCXX_HAVE_STRINGS_H 1


#define _GLIBCXX_HAVE_STRING_H 1


#define _GLIBCXX_HAVE_STRTOF 1


#define _GLIBCXX_HAVE_STRTOLD 1


#define _GLIBCXX_HAVE_STRXFRM_L 1





#define _GLIBCXX_HAVE_SYS_IOCTL_H 1


#define _GLIBCXX_HAVE_SYS_IPC_H 1
# 683 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_HAVE_SYS_PARAM_H 1


#define _GLIBCXX_HAVE_SYS_RESOURCE_H 1


#define _GLIBCXX_HAVE_SYS_SEM_H 1


#define _GLIBCXX_HAVE_SYS_STAT_H 1


#define _GLIBCXX_HAVE_SYS_TIME_H 1


#define _GLIBCXX_HAVE_SYS_TYPES_H 1


#define _GLIBCXX_HAVE_SYS_UIO_H 1





#define _GLIBCXX_HAVE_S_ISREG 1


#define _GLIBCXX_HAVE_TANF 1


#define _GLIBCXX_HAVE_TANHF 1


#define _GLIBCXX_HAVE_TANHL 1


#define _GLIBCXX_HAVE_TANL 1


#define _GLIBCXX_HAVE_TGMATH_H 1


#define _GLIBCXX_HAVE_TLS 1


#define _GLIBCXX_HAVE_UNISTD_H 1


#define _GLIBCXX_HAVE_VFWSCANF 1


#define _GLIBCXX_HAVE_VSWSCANF 1


#define _GLIBCXX_HAVE_VWSCANF 1


#define _GLIBCXX_HAVE_WCHAR_H 1


#define _GLIBCXX_HAVE_WCSTOF 1


#define _GLIBCXX_HAVE_WCTYPE_H 1


#define _GLIBCXX_HAVE_WRITEV 1
# 938 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_ICONV_CONST 



#define LT_OBJDIR ".libs/"





#define _GLIBCXX_PACKAGE_BUGREPORT ""


#define _GLIBCXX_PACKAGE_NAME "package-unused"


#define _GLIBCXX_PACKAGE_STRING "package-unused version-unused"


#define _GLIBCXX_PACKAGE_TARNAME "libstdc++"


#define _GLIBCXX_PACKAGE__GLIBCXX_VERSION "version-unused"
# 978 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define STDC_HEADERS 1





#define _GLIBCXX_ATOMIC_BUILTINS_1 1



#define _GLIBCXX_ATOMIC_BUILTINS_2 1


#define _GLIBCXX_ATOMIC_BUILTINS_4 1



#define _GLIBCXX_ATOMIC_BUILTINS_8 1
# 1004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_HAS_GTHREADS 1


#define _GLIBCXX_HOSTED 1







#define _GLIBCXX_RES_LIMITS 1
# 1024 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_STDIO_MACROS 1


#define _GLIBCXX_SYMVER 1





#define _GLIBCXX_SYMVER_GNU 1






#define _GLIBCXX_USE_C99 1




#define _GLIBCXX_USE_C99_COMPLEX 1




#define _GLIBCXX_USE_C99_COMPLEX_TR1 1



#define _GLIBCXX_USE_C99_CTYPE_TR1 1



#define _GLIBCXX_USE_C99_FENV_TR1 1



#define _GLIBCXX_USE_C99_INTTYPES_TR1 1



#define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1



#define _GLIBCXX_USE_C99_MATH 1



#define _GLIBCXX_USE_C99_MATH_TR1 1



#define _GLIBCXX_USE_C99_STDINT_TR1 1
# 1087 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCXX_USE_GETTIMEOFDAY 1


#define _GLIBCXX_USE_LFS 1


#define _GLIBCXX_USE_LONG_LONG 1





#define _GLIBCXX_USE_NLS 1



#define _GLIBCXX_USE_RANDOM_TR1 1





#define _GLIBCXX_USE_WCHAR_T 1
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stringfwd.h" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stringfwd.h" 3
#define _STRINGFWD_H 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stringfwd.h" 3



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

  template<typename _Alloc>
    class allocator;

  template<class _CharT>
    struct char_traits;

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

  template<> struct char_traits<char>;

  typedef basic_string<char> string;


  template<> struct char_traits<wchar_t>;

  typedef basic_string<wchar_t> wstring;
# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stringfwd.h" 3
}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
#define _GLIBCXX_POSTYPES_H 1

       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#define _STDDEF_H 
#define _STDDEF_H_ 

#define _ANSI_STDDEF_H 

#define __STDDEF_H__ 
# 138 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#define _PTRDIFF_T 
#define _T_PTRDIFF_ 
#define _T_PTRDIFF 
#define __PTRDIFF_T 
#define _PTRDIFF_T_ 
#define _BSD_PTRDIFF_T_ 
#define ___int_ptrdiff_t_h 
#define _GCC_PTRDIFF_T 



typedef long int ptrdiff_t;
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 186 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#define __size_t__ 
#define __SIZE_T__ 
#define _SIZE_T 
#define _SYS_SIZE_T_H 
#define _T_SIZE_ 
#define _T_SIZE 
#define __SIZE_T 
#define _SIZE_T_ 
#define _BSD_SIZE_T_ 
#define _SIZE_T_DEFINED_ 
#define _SIZE_T_DEFINED 
#define _BSD_SIZE_T_DEFINED_ 
#define _SIZE_T_DECLARED 
#define ___int_size_t_h 
#define _GCC_SIZE_T 
#define _SIZET_ 



#define __size_t 





typedef long unsigned int size_t;
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 262 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#define __wchar_t__ 
#define __WCHAR_T__ 
#define _WCHAR_T 
#define _T_WCHAR_ 
#define _T_WCHAR 
#define __WCHAR_T 
#define _WCHAR_T_ 
#define _BSD_WCHAR_T_ 
#define _WCHAR_T_DEFINED_ 
#define _WCHAR_T_DEFINED 
#define _WCHAR_T_H 
#define ___int_wchar_t_h 
#define __INT_WCHAR_T_H 
#define _GCC_WCHAR_T 
#define _WCHAR_T_DECLARED 
# 289 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef _BSD_WCHAR_T_
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3


#define _GLIBCXX_CSTDDEF 1

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

  using ::ptrdiff_t;
  using ::size_t;

}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
#define _WCHAR_H 1





#define __need___FILE 

#define __need_FILE 

# 1 "/usr/include/stdio.h" 1 3 4
# 45 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;







#define __FILE_defined 1

#undef __need_FILE





typedef struct _IO_FILE __FILE;

#define ____FILE_defined 1

#undef __need___FILE
# 38 "/usr/include/wchar.h" 2 3 4

#define __need___va_list 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stdarg.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stdarg.h" 3 4
#undef __need___va_list




#define __GNUC_VA_LIST 
typedef __builtin_va_list __gnuc_va_list;
# 41 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 21 "/usr/include/bits/wchar.h" 3 4
#define _BITS_WCHAR_H 1

#define __WCHAR_MIN (-2147483647 - 1)
#define __WCHAR_MAX (2147483647)
# 43 "/usr/include/wchar.h" 2 3 4


#define __need_size_t 
#define __need_wchar_t 
#define __need_NULL 


#undef __need_wint_t
#define __need_wint_t 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t




#define _WINT_T 




typedef unsigned int wint_t;

#undef __need_wint_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 53 "/usr/include/wchar.h" 2 3 4



#define __CORRECT_ISO_CPP_WCHAR_H_PROTO 
# 81 "/usr/include/wchar.h" 3 4
#define __mbstate_t_defined 1

typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;

#undef __need_mbstate_t








typedef __mbstate_t mbstate_t;







#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX



#define WEOF (0xffffffffu)
# 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 ();



# 1 "/usr/include/xlocale.h" 1 3 4
# 22 "/usr/include/xlocale.h" 3 4
#define _XLOCALE_H 1





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;
# 178 "/usr/include/wchar.h" 2 3 4

extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
    __locale_t __loc) throw ();

extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
     size_t __n, __locale_t __loc) throw ();





extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();



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








extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
        __locale_t __loc) throw ();




extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
    size_t __n, __locale_t __loc) throw ();


extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));





extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));









extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
     throw () __attribute__ ((__pure__));





extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
     throw () __attribute__ ((__pure__));


extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
     throw () __attribute__ ((__pure__));


extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, __const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcspbrk (__const wchar_t *__wcs,
           __const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsstr (wchar_t *__haystack, __const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcsstr (__const wchar_t *__haystack,
          __const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));






extern wchar_t *wcstok (wchar_t *__restrict __s,
   __const wchar_t *__restrict __delim,
   wchar_t **__restrict __ptr) throw ();


extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));





extern "C++" wchar_t *wcswcs (wchar_t *__haystack, __const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wcswcs (__const wchar_t *__haystack,
          __const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 303 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
     throw () __attribute__ ((__pure__));






extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" __const wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c,
           size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));






extern int wmemcmp (__const wchar_t *__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
}







#undef __need_mbstate_t
#undef __need_wint_t
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 2 3



#define _GLIBCXX_CWCHAR 1
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  using ::mbstate_t;

}


#undef btowc
#undef fgetwc
#undef fgetws
#undef fputwc
#undef fputws
#undef fwide
#undef fwprintf
#undef fwscanf
#undef getwc
#undef getwchar
#undef mbrlen
#undef mbrtowc
#undef mbsinit
#undef mbsrtowcs
#undef putwc
#undef putwchar
#undef swprintf
#undef swscanf
#undef ungetwc
#undef vfwprintf

#undef vfwscanf

#undef vswprintf

#undef vswscanf

#undef vwprintf

#undef vwscanf

#undef wcrtomb
#undef wcscat
#undef wcschr
#undef wcscmp
#undef wcscoll
#undef wcscpy
#undef wcscspn
#undef wcsftime
#undef wcslen
#undef wcsncat
#undef wcsncmp
#undef wcsncpy
#undef wcspbrk
#undef wcsrchr
#undef wcsrtombs
#undef wcsspn
#undef wcsstr
#undef wcstod

#undef wcstof

#undef wcstok
#undef wcstol
#undef wcstoul
#undef wcsxfrm
#undef wctob
#undef wmemchr
#undef wmemcmp
#undef wmemcpy
#undef wmemmove
#undef wmemset
#undef wprintf
#undef wscanf



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

  using ::wint_t;

  using ::btowc;
  using ::fgetwc;
  using ::fgetws;
  using ::fputwc;
  using ::fputws;
  using ::fwide;
  using ::fwprintf;
  using ::fwscanf;
  using ::getwc;
  using ::getwchar;
  using ::mbrlen;
  using ::mbrtowc;
  using ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;
  using ::swprintf;
  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;

  using ::vfwscanf;

  using ::vswprintf;

  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;
  using ::wcsftime;
  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;

  using ::wcstof;

  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;
  using ::wcschr;
  using ::wcspbrk;
  using ::wcsrchr;
  using ::wcsstr;
  using ::wmemchr;
# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3
}



#undef wcstold
#undef wcstoll
#undef wcstoull

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






  using ::wcstold;
# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;


}

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

  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 2 3
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {
# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
  typedef long streamoff;
# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
  typedef ptrdiff_t streamsize;
# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }





      fpos&
      operator+=(streamoff __off)
      {
 _M_off += __off;
 return *this;
      }





      fpos&
      operator-=(streamoff __off)
      {
 _M_off -= __off;
 return *this;
      }







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };






  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;
# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/postypes.h" 3
}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iosfwd" 2 3

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

  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;
# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;



}
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception" 3
#define __EXCEPTION__ 

#pragma GCC visibility push(default)



extern "C++" {

namespace std
{
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception" 3
  class exception
  {
  public:
    exception() throw() { }
    virtual ~exception() throw();



    virtual const char* what() const throw();
  };



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



    virtual ~bad_exception() throw();


    virtual const char* what() const throw();
  };


  typedef void (*terminate_handler) ();


  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) throw();



  void terminate() __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) throw();



  void unexpected() __attribute__ ((__noreturn__));
# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception" 3
  bool uncaught_exception() throw();


}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 138 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception" 3
  void __verbose_terminate_handler();

}

}

#pragma GCC visibility pop
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3
#define _CHAR_TRAITS_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
#define _STL_ALGOBASE_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/functexcept.h" 3
#define _FUNCTEXCEPT_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception_defines.h" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception_defines.h" 3
#define _EXCEPTION_DEFINES_H 1
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/exception_defines.h" 3
#define __try try
#define __catch(X) catch(X)
#define __throw_exception_again throw
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/functexcept.h" 2 3

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


  void
  __throw_bad_exception(void) __attribute__((__noreturn__));


  void
  __throw_bad_alloc(void) __attribute__((__noreturn__));


  void
  __throw_bad_cast(void) __attribute__((__noreturn__));

  void
  __throw_bad_typeid(void) __attribute__((__noreturn__));


  void
  __throw_logic_error(const char*) __attribute__((__noreturn__));

  void
  __throw_domain_error(const char*) __attribute__((__noreturn__));

  void
  __throw_invalid_argument(const char*) __attribute__((__noreturn__));

  void
  __throw_length_error(const char*) __attribute__((__noreturn__));

  void
  __throw_out_of_range(const char*) __attribute__((__noreturn__));

  void
  __throw_runtime_error(const char*) __attribute__((__noreturn__));

  void
  __throw_range_error(const char*) __attribute__((__noreturn__));

  void
  __throw_overflow_error(const char*) __attribute__((__noreturn__));

  void
  __throw_underflow_error(const char*) __attribute__((__noreturn__));


  void
  __throw_ios_failure(const char*) __attribute__((__noreturn__));

  void
  __throw_system_error(int) __attribute__((__noreturn__));

}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 3
#define _CPP_TYPE_TRAITS_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 3
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {

  template<typename _Iterator, typename _Container>
    class __normal_iterator;

}

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

  struct __true_type { };
  struct __false_type { };

  template<bool>
    struct __truth_type
    { typedef __false_type __type; };

  template<>
    struct __truth_type<true>
    { typedef __true_type __type; };



  template<class _Sp, class _Tp>
    struct __traitor
    {
      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
      typedef typename __truth_type<__value>::__type __type;
    };


  template<typename, typename>
    struct __are_same
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

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


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

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




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




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

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

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

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


  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 3
  template<>
    struct __is_integer<short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

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

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

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

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

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

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

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




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


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

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

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




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

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




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

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




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




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




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




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

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


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


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

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

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

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




  template<typename _Tp>
    struct __is_move_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cpp_type_traits.h" 3
}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/type_traits.h" 1 3
# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/type_traits.h" 3
#define _EXT_TYPE_TRAITS 1

       
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/type_traits.h" 3




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


  template<bool, typename>
    struct __enable_if
    { };

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



  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct __conditional_type
    { typedef _Iftrue __type; };

  template<typename _Iftrue, typename _Iffalse>
    struct __conditional_type<false, _Iftrue, _Iffalse>
    { typedef _Iffalse __type; };



  template<typename _Tp>
    struct __add_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __add_unsigned<char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<signed char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<short>
    { typedef unsigned short __type; };

  template<>
    struct __add_unsigned<int>
    { typedef unsigned int __type; };

  template<>
    struct __add_unsigned<long>
    { typedef unsigned long __type; };

  template<>
    struct __add_unsigned<long long>
    { typedef unsigned long long __type; };


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



  template<typename _Tp>
    struct __remove_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __remove_unsigned<char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned short>
    { typedef short __type; };

  template<>
    struct __remove_unsigned<unsigned int>
    { typedef int __type; };

  template<>
    struct __remove_unsigned<unsigned long>
    { typedef long __type; };

  template<>
    struct __remove_unsigned<unsigned long long>
    { typedef long long __type; };


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



  template<typename _Type>
    inline bool
    __is_null_pointer(_Type* __ptr)
    { return __ptr == 0; }

  template<typename _Type>
    inline bool
    __is_null_pointer(_Type)
    { return false; }



  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
    struct __promote
    { typedef double __type; };

  template<typename _Tp>
    struct __promote<_Tp, false>
    { typedef _Tp __type; };

  template<typename _Tp, typename _Up>
    struct __promote_2
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;

    public:
      typedef __typeof__(__type1() + __type2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp>
    struct __promote_3
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;
      typedef typename __promote<_Vp>::__type __type3;

    public:
      typedef __typeof__(__type1() + __type2() + __type3()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
    struct __promote_4
    {
    private:
      typedef typename __promote<_Tp>::__type __type1;
      typedef typename __promote<_Up>::__type __type2;
      typedef typename __promote<_Vp>::__type __type3;
      typedef typename __promote<_Wp>::__type __type4;

    public:
      typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
    };

}
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/numeric_traits.h" 1 3
# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/numeric_traits.h" 3
#define _EXT_NUMERIC_TRAITS 1

       
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/numeric_traits.h" 3




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



#define __glibcxx_signed(_Tp) ((_Tp)(-1) < 0)
#define __glibcxx_digits(_Tp) (sizeof(_Tp) * __CHAR_BIT__ - __glibcxx_signed(_Tp))


#define __glibcxx_min(_Tp) (__glibcxx_signed(_Tp) ? (_Tp)1 << __glibcxx_digits(_Tp) : (_Tp)0)


#define __glibcxx_max(_Tp) (__glibcxx_signed(_Tp) ? (((((_Tp)1 << (__glibcxx_digits(_Tp) - 1)) - 1) << 1) + 1) : ~(_Tp)0)



  template<typename _Value>
    struct __numeric_traits_integer
    {

      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);



      static const bool __is_signed = ((_Value)(-1) < 0);
      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
    };

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__min;

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__max;

  template<typename _Value>
    const bool __numeric_traits_integer<_Value>::__is_signed;

  template<typename _Value>
    const int __numeric_traits_integer<_Value>::__digits;

#undef __glibcxx_signed
#undef __glibcxx_digits
#undef __glibcxx_min
#undef __glibcxx_max

#define __glibcxx_floating(_Tp,_Fval,_Dval,_LDval) (std::__are_same<_Tp, float>::__value ? _Fval : std::__are_same<_Tp, double>::__value ? _Dval : _LDval)



#define __glibcxx_max_digits10(_Tp) (2 + __glibcxx_floating(_Tp, __FLT_MANT_DIG__, __DBL_MANT_DIG__, __LDBL_MANT_DIG__) * 3010 / 10000)



#define __glibcxx_digits10(_Tp) __glibcxx_floating(_Tp, __FLT_DIG__, __DBL_DIG__, __LDBL_DIG__)


#define __glibcxx_max_exponent10(_Tp) __glibcxx_floating(_Tp, __FLT_MAX_10_EXP__, __DBL_MAX_10_EXP__, __LDBL_MAX_10_EXP__)



  template<typename _Value>
    struct __numeric_traits_floating
    {

      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 3010 / 10000);


      static const bool __is_signed = true;
      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
    };

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__max_digits10;

  template<typename _Value>
    const bool __numeric_traits_floating<_Value>::__is_signed;

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__digits10;

  template<typename _Value>
    const int __numeric_traits_floating<_Value>::__max_exponent10;

  template<typename _Value>
    struct __numeric_traits
    : public __conditional_type<std::__is_integer<_Value>::__value,
    __numeric_traits_integer<_Value>,
    __numeric_traits_floating<_Value> >::__type
    { };

}

#undef __glibcxx_floating
#undef __glibcxx_max_digits10
#undef __glibcxx_digits10
#undef __glibcxx_max_exponent10
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 3
#define _STL_PAIR_H 1

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/move.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/move.h" 3
#define _MOVE_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/move.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/concept_check.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/concept_check.h" 3
#define _CONCEPT_CHECK_H 1

       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/concept_check.h" 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/concept_check.h" 3
#define __glibcxx_function_requires(...) 
#define __glibcxx_class_requires(_a,_b) 
#define __glibcxx_class_requires2(_a,_b,_c) 
#define __glibcxx_class_requires3(_a,_b,_c,_d) 
#define __glibcxx_class_requires4(_a,_b,_c,_d,_e) 
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/move.h" 2 3
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/move.h" 3
#define _GLIBCXX_MOVE(_Tp) (_Tp)


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







  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    {

     

      _Tp __tmp = (__a);
      __a = (__b);
      __b = (__tmp);
    }



  template<typename _Tp, size_t _Nm>
    inline void
    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
    {
      for (size_t __n = 0; __n < _Nm; ++__n)
 swap(__a[__n], __b[__n]);
    }

}
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 2 3


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


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

      _T1 first;
      _T2 second;





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


      pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }
# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 3
      template<class _U1, class _U2>
        pair(const pair<_U1, _U2>& __p)
 : first(__p.first),
   second(__p.second) { }
# 141 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 3
    };


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


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


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


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


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


  template<class _T1, class _T2>
    inline bool
    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x < __y); }
# 213 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 259 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_pair.h" 3
}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_types.h" 1 3
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_types.h" 3
#define _STL_ITERATOR_BASE_TYPES_H 1

       
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_types.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_types.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 { };
# 102 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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(); }



}
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_funcs.h" 1 3
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
#define _STL_ITERATOR_BASE_FUNCS_H 1

       
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_funcs.h" 3


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

  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::difference_type
    __distance(_InputIterator __first, _InputIterator __last,
               input_iterator_tag)
    {

     

      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }

  template<typename _RandomAccessIterator>
    inline typename iterator_traits<_RandomAccessIterator>::difference_type
    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
               random_access_iterator_tag)
    {

     

      return __last - __first;
    }
# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

      typename iterator_traits<_InputIterator>::difference_type __d = __n;
      std::__advance(__i, __d, std::__iterator_category(__i));
    }
# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
}
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 1 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
#define _STL_ITERATOR_H 1





namespace std __attribute__ ((__visibility__ ("default"))) {
# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
    };
# 276 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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(); }
# 388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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) { }
# 414 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_back(__value);
 return *this;
      }
# 431 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator*()
      { return *this; }


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


      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 457 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 472 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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) { }
# 497 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_front(__value);
 return *this;
      }
# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator*()
      { return *this; }


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


      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 540 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 559 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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) {}
# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }
# 620 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
      insert_iterator&
      operator*()
      { return *this; }


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


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 646 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _Container, typename _Iterator>
    inline insert_iterator<_Container>
    inserter(_Container& __x, _Iterator __i)
    {
      return insert_iterator<_Container>(__x,
      typename _Container::iterator(__i));
    }

}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 665 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_current;

    public:
      typedef _Iterator iterator_type;
      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 __enable_if<
              (std::__are_same<_Iter, typename _Container::pointer>::__value),
        _Container>::__type>& __i)
        : _M_current(__i.base()) { }


      reference
      operator*() const
      { return *_M_current; }

      pointer
      operator->() const
      { return _M_current; }

      __normal_iterator&
      operator++()
      {
 ++_M_current;
 return *this;
      }

      __normal_iterator
      operator++(int)
      { return __normal_iterator(_M_current++); }


      __normal_iterator&
      operator--()
      {
 --_M_current;
 return *this;
      }

      __normal_iterator
      operator--(int)
      { return __normal_iterator(_M_current--); }


      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const
      { return _M_current; }
    };
# 763 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() != __rhs.base(); }


  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    inline bool
    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() >= __rhs.base(); }





  template<typename _IteratorL, typename _IteratorR, typename _Container>







    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)

    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline typename __normal_iterator<_Iterator, _Container>::difference_type
    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

}
# 1038 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_iterator.h" 3
#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/debug/debug.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/debug/debug.h" 3
#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;
}



#define _GLIBCXX_DEBUG_ASSERT(_Condition) 
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition) 
#define _GLIBCXX_DEBUG_ONLY(_Statement) ;
#define __glibcxx_requires_cond(_Cond,_Msg) 
#define __glibcxx_requires_valid_range(_First,_Last) 
#define __glibcxx_requires_sorted(_First,_Last) 
#define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) 
#define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) 
#define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) 
#define __glibcxx_requires_partitioned_lower(_First,_Last,_Value) 
#define __glibcxx_requires_partitioned_upper(_First,_Last,_Value) 
#define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) 
#define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) 
#define __glibcxx_requires_heap(_First,_Last) 
#define __glibcxx_requires_heap_pred(_First,_Last,_Pred) 
#define __glibcxx_requires_nonempty() 
#define __glibcxx_requires_string(_String) 
#define __glibcxx_requires_string_len(_String,_Len) 
#define __glibcxx_requires_subscript(_N) 
# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 2 3


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




  template<bool _BoolType>
    struct __iter_swap
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          typedef typename iterator_traits<_ForwardIterator1>::value_type
            _ValueType1;
          _ValueType1 __tmp = (*__a);
          *__a = (*__b);
          *__b = (__tmp);
 }
    };

  template<>
    struct __iter_swap<true>
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          swap(*__a, *__b);
        }
    };
# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 156 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {

     

     

      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 184 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }




  template<typename _Iterator,
    bool _IsNormal = __is_normal_iterator<_Iterator>::__value>
    struct __niter_base
    {
      static _Iterator
      __b(_Iterator __it)
      { return __it; }
    };

  template<typename _Iterator>
    struct __niter_base<_Iterator, true>
    {
      static typename _Iterator::iterator_type
      __b(_Iterator __it)
      { return __it.base(); }
    };


  template<typename _Iterator,
    bool _IsMove = __is_move_iterator<_Iterator>::__value>
    struct __miter_base
    {
      static _Iterator
      __b(_Iterator __it)
      { return __it; }
    };

  template<typename _Iterator>
    struct __miter_base<_Iterator, true>
    {
      static typename _Iterator::iterator_type
      __b(_Iterator __it)
      { return __it.base(); }
    };







  template<bool, bool, typename>
    struct __copy_move
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
   for (; __first != __last; ++__result, ++__first)
     *__result = *__first;
   return __result;
 }
    };
# 333 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = *__first;
       ++__first;
       ++__result;
     }
   return __result;
 }
    };
# 371 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   __builtin_memmove(__result, __first,
       sizeof(_Tp) * (__last - __first));
   return __result + (__last - __first);
 }
    };

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
      typedef typename iterator_traits<_II>::iterator_category _Category;
      const bool __simple = (__is_pod(_ValueTypeI)
                      && __is_pointer<_II>::__value
                      && __is_pointer<_OI>::__value
        && __are_same<_ValueTypeI, _ValueTypeO>::__value);

      return std::__copy_move<_IsMove, __simple,
                       _Category>::__copy_m(__first, __last, __result);
    }



  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      return _OI(std::__copy_move_a<_IsMove>
   (std::__niter_base<_II>::__b(__first),
    std::__niter_base<_II>::__b(__last),
    std::__niter_base<_OI>::__b(__result)));
    }
# 456 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {

     
     

      ;

      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
       (std::__miter_base<_II>::__b(__first),
        std::__miter_base<_II>::__b(__last), __result));
    }
# 506 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
#define _GLIBCXX_MOVE3(_Tp,_Up,_Vp) std::copy(_Tp, _Up, _Vp)


  template<bool, bool, typename>
    struct __copy_move_backward
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   while (__first != __last)
     *--__result = *--__last;
   return __result;
 }
    };
# 537 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   typename iterator_traits<_BI1>::difference_type __n;
   for (__n = __last - __first; __n > 0; --__n)
     *--__result = *--__last;
   return __result;
 }
    };
# 567 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   const ptrdiff_t _Num = __last - __first;
   __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
   return __result - _Num;
 }
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_pod(_ValueType1)
                      && __is_pointer<_BI1>::__value
                      && __is_pointer<_BI2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__copy_move_backward<_IsMove, __simple,
                                _Category>::__copy_move_b(__first,
         __last,
         __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      return _BI2(std::__copy_move_backward_a<_IsMove>
    (std::__niter_base<_BI1>::__b(__first),
     std::__niter_base<_BI1>::__b(__last),
     std::__niter_base<_BI2>::__b(__result)));
    }
# 626 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
       (std::__miter_base<_BI1>::__b(__first),
        std::__miter_base<_BI1>::__b(__last), __result));
    }
# 681 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::copy_backward(_Tp, _Up, _Vp)


  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      for (; __first != __last; ++__first)
 *__first = __value;
    }

  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
 *__first = __tmp;
    }


  template<typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;
      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
         __last - __first);
    }
# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {

     

      ;

      std::__fill_a(std::__niter_base<_ForwardIterator>::__b(__first),
      std::__niter_base<_ForwardIterator>::__b(__last), __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (; __n > 0; --__n, ++__first)
 *__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __n > 0; --__n, ++__first)
 *__first = __tmp;
      return __first;
    }

  template<typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
    {
      std::__fill_a(__first, __first + __n, __c);
      return __first + __n;
    }
# 783 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _OI, typename _Size, typename _Tp>
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {

     

      return _OI(std::__fill_n_a(std::__niter_base<_OI>::__b(__first),
     __n, __value));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
        static bool
        equal(_II1 __first1, _II1 __last1, _II2 __first2)
        {
   for (; __first1 != __last1; ++__first1, ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
        static bool
        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
        {
   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
       * (__last1 - __first1));
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple = (__is_integer<_ValueType1>::__value
                      && __is_pointer<_II1>::__value
                      && __is_pointer<_II2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }


  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
        static _II1
        __newlast1(_II1, _II1 __last1, _II2, _II2)
        { return __last1; }

      template<typename _II>
        static bool
        __cnd2(_II __first, _II __last)
        { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
        static _RAI1
        __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
        {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
        static bool
        __cnd2(_RAI, _RAI)
        { return true; }
    };

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
        static bool __lc(_II1, _II1, _II2, _II2);
    };

  template<bool _BoolType>
    template<typename _II1, typename _II2>
      bool
      __lexicographical_compare<_BoolType>::
      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      {
 typedef typename iterator_traits<_II1>::iterator_category _Category1;
 typedef typename iterator_traits<_II2>::iterator_category _Category2;
 typedef std::__lc_rai<_Category1, _Category2> __rai_type;

 __last1 = __rai_type::__newlast1(__first1, __last1,
      __first2, __last2);
 for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
      ++__first1, ++__first2)
   {
     if (*__first1 < *__first2)
       return true;
     if (*__first2 < *__first1)
       return false;
   }
 return __first1 == __last1 && __first2 != __last2;
      }

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
        static bool
        __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   const int __result = __builtin_memcmp(__first1, __first2,
      std::min(__len1, __len2));
   return __result != 0 ? __result < 0 : __len1 < __len2;
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
 (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
  && __is_pointer<_II1>::__value
  && __is_pointer<_II2>::__value);

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }

}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 950 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {

     
     
     


      ;

      return std::__equal_aux(std::__niter_base<_II1>::__b(__first1),
         std::__niter_base<_II1>::__b(__last1),
         std::__niter_base<_II2>::__b(__first2));
    }
# 982 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return true;
    }
# 1013 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {

      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
     
     
     
     
      ;
      ;

      return std::__lexicographical_compare_aux
 (std::__niter_base<_II1>::__b(__first1),
  std::__niter_base<_II1>::__b(__last1),
  std::__niter_base<_II2>::__b(__first2),
  std::__niter_base<_II2>::__b(__last2));
    }
# 1048 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2, typename _Compare>
    bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2, _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;


     
     
      ;
      ;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
    ++__first1, ++__first2)
 {
   if (__comp(*__first1, *__first2))
     return true;
   if (__comp(*__first2, *__first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }
# 1088 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }

}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 897 "/usr/include/wchar.h" 3 4
#undef __need_mbstate_t
#undef __need_wint_t
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwchar" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 2 3





#define _CHAR_TRAITS_EOF (-1)


namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3
  template<typename _CharT>
    struct _Char_types
    {
      typedef unsigned long int_type;
      typedef std::streampos pos_type;
      typedef std::streamoff off_type;
      typedef std::mbstate_t state_type;
    };
# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;
      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static std::size_t
      length(const char_type* __s);

      static const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((-1)); }

      static int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
    };

  template<typename _CharT>
    int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
          __n * sizeof(char_type)));
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {

      std::copy(__s2, __s2 + __n, __s1);
      return __s1;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {

      std::fill_n(__s, __n, __a);
      return __s;
    }

}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef int int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return __builtin_memcmp(__s1, __s2, __n); }

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

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

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

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

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }



      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((-1)); }

      static int_type
      not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
  };




  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t char_type;
      typedef wint_t int_type;
      typedef streamoff off_type;
      typedef wstreampos pos_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcmp(__s1, __s2, __n); }

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

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return wmemchr(__s, __a, __n); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemmove(__s1, __s2, __n); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcpy(__s1, __s2, __n); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return wmemset(__s, __a, __n); }

      static char_type
      to_char_type(const int_type& __c)
      { return char_type(__c); }

      static int_type
      to_int_type(const char_type& __c)
      { return int_type(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>((0xffffffffu)); }

      static int_type
      not_eof(const int_type& __c)
      { return eq_int_type(__c, eof()) ? 0 : __c; }
  };


}
# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/char_traits.h" 3
#undef _CHAR_TRAITS_EOF
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/localefwd.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/localefwd.h" 3
#define _LOCALE_FWD_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/localefwd.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
#define _GLIBCXX_CXX_LOCALE_H 1

       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/clocale" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/clocale" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/clocale" 3


# 1 "/usr/include/locale.h" 1 3 4
# 24 "/usr/include/locale.h" 3 4
#define _LOCALE_H 1



#define __need_NULL 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 25 "/usr/include/bits/locale.h" 3 4
#define _BITS_LOCALE_H 1

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



#define LC_CTYPE __LC_CTYPE
#define LC_NUMERIC __LC_NUMERIC
#define LC_TIME __LC_TIME
#define LC_COLLATE __LC_COLLATE
#define LC_MONETARY __LC_MONETARY
#define LC_MESSAGES __LC_MESSAGES
#define LC_ALL __LC_ALL
#define LC_PAPER __LC_PAPER
#define LC_NAME __LC_NAME
#define LC_ADDRESS __LC_ADDRESS
#define LC_TELEPHONE __LC_TELEPHONE
#define LC_MEASUREMENT __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION





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





#define LC_CTYPE_MASK (1 << __LC_CTYPE)
#define LC_NUMERIC_MASK (1 << __LC_NUMERIC)
#define LC_TIME_MASK (1 << __LC_TIME)
#define LC_COLLATE_MASK (1 << __LC_COLLATE)
#define LC_MONETARY_MASK (1 << __LC_MONETARY)
#define LC_MESSAGES_MASK (1 << __LC_MESSAGES)
#define LC_PAPER_MASK (1 << __LC_PAPER)
#define LC_NAME_MASK (1 << __LC_NAME)
#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
# 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 ();



#define LC_GLOBAL_LOCALE ((__locale_t) -1L)



}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/clocale" 2 3


#define _GLIBCXX_CLOCALE 1


#undef setlocale
#undef localeconv

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

  using ::lconv;
  using ::setlocale;
  using ::localeconv;

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3

#define _GLIBCXX_C_LOCALE_GNU 1

#define _GLIBCXX_NUM_CATEGORIES 6


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

  extern "C" __typeof(uselocale) __uselocale;

}


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

  typedef __locale_t __c_locale;





  inline int
  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
     char* __out,
     const int __size __attribute__ ((__unused__)),
     const char* __fmt, ...)
  {

    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
    __builtin_va_list __args;
    __builtin_va_start(__args, __fmt);


    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);




    __builtin_va_end(__args);


    __gnu_cxx::__uselocale(__old);







    return __ret;
  }

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/localefwd.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 25 "/usr/include/ctype.h" 3 4
#define _CTYPE_H 1


# 1 "/usr/include/bits/types.h" 1 3 4
# 25 "/usr/include/bits/types.h" 3 4
#define _BITS_TYPES_H 1


# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 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;
# 99 "/usr/include/bits/types.h" 3 4
#define __S16_TYPE short int
#define __U16_TYPE unsigned short int
#define __S32_TYPE int
#define __U32_TYPE unsigned int
#define __SLONGWORD_TYPE long int
#define __ULONGWORD_TYPE unsigned long int
# 118 "/usr/include/bits/types.h" 3 4
#define __SQUAD_TYPE long int
#define __UQUAD_TYPE unsigned long int
#define __SWORD_TYPE long int
#define __UWORD_TYPE unsigned long int
#define __SLONG32_TYPE int
#define __ULONG32_TYPE unsigned int
#define __S64_TYPE long int
#define __U64_TYPE unsigned long int

#define __STD_TYPE typedef



# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 25 "/usr/include/bits/typesizes.h" 3 4
#define _BITS_TYPESIZES_H 1




#define __DEV_T_TYPE __UQUAD_TYPE
#define __UID_T_TYPE __U32_TYPE
#define __GID_T_TYPE __U32_TYPE
#define __INO_T_TYPE __ULONGWORD_TYPE
#define __INO64_T_TYPE __UQUAD_TYPE
#define __MODE_T_TYPE __U32_TYPE
#define __NLINK_T_TYPE __UWORD_TYPE
#define __OFF_T_TYPE __SLONGWORD_TYPE
#define __OFF64_T_TYPE __SQUAD_TYPE
#define __PID_T_TYPE __S32_TYPE
#define __RLIM_T_TYPE __ULONGWORD_TYPE
#define __RLIM64_T_TYPE __UQUAD_TYPE
#define __BLKCNT_T_TYPE __SLONGWORD_TYPE
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
#define __FSBLKCNT_T_TYPE __ULONGWORD_TYPE
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
#define __FSFILCNT_T_TYPE __ULONGWORD_TYPE
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
#define __ID_T_TYPE __U32_TYPE
#define __CLOCK_T_TYPE __SLONGWORD_TYPE
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
#define __DADDR_T_TYPE __S32_TYPE
#define __SWBLK_T_TYPE __SLONGWORD_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __BLKSIZE_T_TYPE __SLONGWORD_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE


#define __FD_SETSIZE 1024
# 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;


#undef __STD_TYPE
# 29 "/usr/include/ctype.h" 2 3 4

extern "C" {
# 41 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 20 "/usr/include/endian.h" 3 4
#define _ENDIAN_H 1
# 32 "/usr/include/endian.h" 3 4
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412


# 1 "/usr/include/bits/endian.h" 1 3 4






#define __BYTE_ORDER __LITTLE_ENDIAN
# 38 "/usr/include/endian.h" 2 3 4




#define __FLOAT_WORD_ORDER __BYTE_ORDER



#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define BIG_ENDIAN __BIG_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER



#define __LONG_LONG_PAIR(HI,LO) LO, HI







# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 26 "/usr/include/bits/byteswap.h" 3 4
#define _BITS_BYTESWAP_H 1

# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 29 "/usr/include/bits/byteswap.h" 2 3 4


#define __bswap_constant_16(x) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))



#define __bswap_16(x) (__extension__ ({ register unsigned short int __v, __x = (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_16 (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
# 55 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_constant_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
# 68 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_32(x) (__extension__ ({ register unsigned int __v, __x = (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_32 (__x); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }))
# 100 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_constant_64(x) ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56))
# 111 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_64(x) (__extension__ ({ register unsigned long __v, __x = (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_64 (__x); else __asm__ ("bswap %q0" : "=r" (__v) : "0" (__x)); __v; }))
# 62 "/usr/include/endian.h" 2 3 4


#define htobe16(x) __bswap_16 (x)
#define htole16(x) (x)
#define be16toh(x) __bswap_16 (x)
#define le16toh(x) (x)

#define htobe32(x) __bswap_32 (x)
#define htole32(x) (x)
#define be32toh(x) __bswap_32 (x)
#define le32toh(x) (x)

#define htobe64(x) __bswap_64 (x)
#define htole64(x) (x)
#define be64toh(x) __bswap_64 (x)
#define le64toh(x) (x)
# 42 "/usr/include/ctype.h" 2 3 4



#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))


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

#define __isctype(c,type) ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)


#define __isascii(c) (((c) & ~0x7f) == 0)
#define __toascii(c) ((c) & 0x7f)

#define __exctype(name) extern int name (int) __THROW







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



#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
# 237 "/usr/include/ctype.h" 3 4
#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)


#define __exctype_l(name) extern int name (int, __locale_t) __THROW






extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();



extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 "/usr/include/ctype.h" 3 4
}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 2 3


#define _GLIBCXX_CCTYPE 1


#undef isalnum
#undef isalpha
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
#undef tolower
#undef toupper

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

  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;

}
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/localefwd.h" 2 3

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


  class locale;

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


  class ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, char, mbstate_t>;

  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;



  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;

}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
#define _IOS_BASE_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/atomicity.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/atomicity.h" 3
#define _GLIBCXX_ATOMICITY_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
# 27 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
#define _GLIBCXX_GCC_GTHR_H 


#pragma GCC visibility push(default)
# 159 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
#define _GLIBCXX_GTHREAD_USE_WEAK 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
# 28 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
#define _GLIBCXX_GCC_GTHR_POSIX_H 




#define __GTHREADS 1
#define __GTHREADS_CXX0X 1






# 1 "/usr/include/pthread.h" 1 3 4
# 21 "/usr/include/pthread.h" 3 4
#define _PTHREAD_H 1



# 1 "/usr/include/sched.h" 1 3 4
# 21 "/usr/include/sched.h" 3 4
#define _SCHED_H 1






#define __need_size_t 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 30 "/usr/include/sched.h" 2 3 4

#define __need_timespec 
# 1 "/usr/include/time.h" 1 3 4
# 67 "/usr/include/time.h" 3 4
#undef __need_clock_t
# 83 "/usr/include/time.h" 3 4
#undef __need_time_t
# 95 "/usr/include/time.h" 3 4
#undef __clockid_time_t
# 107 "/usr/include/time.h" 3 4
#undef __need_timer_t






#define __timespec_defined 1





struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };


#undef __need_timespec
# 33 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/bits/sched.h" 1 3 4
# 30 "/usr/include/bits/sched.h" 3 4
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2

#define SCHED_BATCH 3




#define CSIGNAL 0x000000ff
#define CLONE_VM 0x00000100
#define CLONE_FS 0x00000200
#define CLONE_FILES 0x00000400
#define CLONE_SIGHAND 0x00000800
#define CLONE_PTRACE 0x00002000
#define CLONE_VFORK 0x00004000

#define CLONE_PARENT 0x00008000

#define CLONE_THREAD 0x00010000
#define CLONE_NEWNS 0x00020000
#define CLONE_SYSVSEM 0x00040000
#define CLONE_SETTLS 0x00080000
#define CLONE_PARENT_SETTID 0x00100000

#define CLONE_CHILD_CLEARTID 0x00200000

#define CLONE_DETACHED 0x00400000
#define CLONE_UNTRACED 0x00800000

#define CLONE_CHILD_SETTID 0x01000000

#define CLONE_NEWUTS 0x04000000
#define CLONE_NEWIPC 0x08000000
#define CLONE_NEWUSER 0x10000000
#define CLONE_NEWPID 0x20000000
#define CLONE_NEWNET 0x40000000
#define CLONE_IO 0x80000000



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


}





#define __defined_schedparam 1

struct __sched_param
  {
    int __sched_priority;
  };
#undef __need_schedparam




#define __cpu_set_t_defined 

#define __CPU_SETSIZE 1024
#define __NCPUBITS (8 * sizeof (__cpu_mask))


typedef unsigned long int __cpu_mask;


#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))


typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;



#define __CPU_ZERO_S(setsize,cpusetp) do __builtin_memset (cpusetp, '\0', setsize); while (0)
# 139 "/usr/include/bits/sched.h" 3 4
#define __CPU_SET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu < 8 * (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))






#define __CPU_CLR_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu < 8 * (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))






#define __CPU_ISSET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu < 8 * (setsize) ? ((((__const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))







#define __CPU_COUNT_S(setsize,cpusetp) __sched_cpucount (setsize, cpusetp)



#define __CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
# 180 "/usr/include/bits/sched.h" 3 4
#define __CPU_OP_S(setsize,destset,srcset1,srcset2,op) (__extension__ ({ cpu_set_t *__dest = (destset); __const __cpu_mask *__arr1 = (srcset1)->__bits; __const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))
# 191 "/usr/include/bits/sched.h" 3 4
#define __CPU_ALLOC_SIZE(count) ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))

#define __CPU_ALLOC(count) __sched_cpualloc (count)
#define __CPU_FREE(cpuset) __sched_cpufree (cpuset)

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

#define sched_priority __sched_priority


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




#define CPU_SETSIZE __CPU_SETSIZE
#define CPU_SET(cpu,cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_CLR(cpu,cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), cpusetp)

#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)

#define CPU_SET_S(cpu,setsize,cpusetp) __CPU_SET_S (cpu, setsize, cpusetp)
#define CPU_CLR_S(cpu,setsize,cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp)
#define CPU_ISSET_S(cpu,setsize,cpusetp) __CPU_ISSET_S (cpu, setsize, cpusetp)

#define CPU_ZERO_S(setsize,cpusetp) __CPU_ZERO_S (setsize, cpusetp)
#define CPU_COUNT_S(setsize,cpusetp) __CPU_COUNT_S (setsize, cpusetp)

#define CPU_EQUAL(cpusetp1,cpusetp2) __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2)

#define CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2)


#define CPU_AND(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &)

#define CPU_OR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |)

#define CPU_XOR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^)

#define CPU_AND_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, &)

#define CPU_OR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, |)

#define CPU_XOR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, ^)


#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
#define CPU_ALLOC(count) __CPU_ALLOC (count)
#define CPU_FREE(cpuset) __CPU_FREE (cpuset)



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
# 27 "/usr/include/time.h" 3 4
#define _TIME_H 1


extern "C" {





#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 26 "/usr/include/bits/time.h" 3 4
#define _BITS_TIME_H 1







#define CLOCKS_PER_SEC 1000000l
# 46 "/usr/include/bits/time.h" 3 4
#define CLOCK_REALTIME 0

#define CLOCK_MONOTONIC 1

#define CLOCK_PROCESS_CPUTIME_ID 2

#define CLOCK_THREAD_CPUTIME_ID 3


#define TIMER_ABSTIME 1
# 43 "/usr/include/time.h" 2 3 4
# 54 "/usr/include/time.h" 3 4
#define __clock_t_defined 1





typedef __clock_t clock_t;






#undef __need_clock_t


#define __time_t_defined 1





typedef __time_t time_t;






#undef __need_time_t



#define __clockid_t_defined 1




typedef __clockid_t clockid_t;


#undef __clockid_time_t



#define __timer_t_defined 1




typedef __timer_t timer_t;


#undef __need_timer_t
# 127 "/usr/include/time.h" 3 4
#undef __need_timespec





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;





typedef __pid_t pid_t;
#define __pid_t_defined 







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





#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
# 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

#define __need_sigset_t 
# 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
# 22 "/usr/include/bits/sigset.h" 3 4
#define _SIGSET_H_types 1

typedef int __sig_atomic_t;



#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 34 "/usr/include/signal.h" 2 3 4
# 49 "/usr/include/signal.h" 3 4
#define __sigset_t_defined 
typedef __sigset_t sigset_t;

#undef __need_sigset_t
# 408 "/usr/include/signal.h" 3 4
}
# 30 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 21 "/usr/include/bits/pthreadtypes.h" 3 4
#define _BITS_PTHREADTYPES_H 1

# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4


#define __SIZEOF_PTHREAD_ATTR_T 56
#define __SIZEOF_PTHREAD_MUTEX_T 40
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
#define __SIZEOF_PTHREAD_COND_T 48
#define __SIZEOF_PTHREAD_CONDATTR_T 4
#define __SIZEOF_PTHREAD_RWLOCK_T 56
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
#define __SIZEOF_PTHREAD_BARRIER_T 32
#define __SIZEOF_PTHREAD_BARRIERATTR_T 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;
#define __PTHREAD_MUTEX_HAVE_PREV 1
# 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;
# 31 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 21 "/usr/include/bits/setjmp.h" 3 4
#define _BITS_SETJMP_H 1





# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 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



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 33 "/usr/include/pthread.h" 2 3 4



enum
{
  PTHREAD_CREATE_JOINABLE,
#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
  PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED 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
};





#define PTHREAD_MUTEX_INITIALIZER { { 0, 0, 0, 0, 0, 0, { 0, 0 } } }


#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, { 0, 0 } } }

#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, 0, { 0, 0 } } }

#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, 0, { 0, 0 } } }
# 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
};


#define PTHREAD_RWLOCK_INITIALIZER { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }



#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } }
# 149 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,
#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED
  PTHREAD_EXPLICIT_SCHED
#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED
};



enum
{
  PTHREAD_SCOPE_SYSTEM,
#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM
  PTHREAD_SCOPE_PROCESS
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
};



enum
{
  PTHREAD_PROCESS_PRIVATE,
#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
  PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
};




#define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } }



struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,
#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE
  PTHREAD_CANCEL_DISABLE
#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE
};
enum
{
  PTHREAD_CANCEL_DEFERRED,
#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
  PTHREAD_CANCEL_ASYNCHRONOUS
#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS
};
#define PTHREAD_CANCELED ((void *) -1)



#define PTHREAD_ONCE_INIT 0






#define PTHREAD_BARRIER_SERIAL_THREAD -1



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



#define __cleanup_fct_attribute 




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); }
};
# 549 "/usr/include/pthread.h" 3 4
#define pthread_cleanup_push(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg)





#define pthread_cleanup_pop(execute) __clframe.__setdoit (execute); } while (0)







#define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg); __clframe.__defer ()







#define pthread_cleanup_pop_restore_np(execute) __clframe.__restore (); __clframe.__setdoit (execute); } while (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
}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
# 1 "/usr/include/unistd.h" 1 3 4
# 24 "/usr/include/unistd.h" 3 4
#define _UNISTD_H 1



extern "C" {






#define _POSIX_VERSION 200809L
# 54 "/usr/include/unistd.h" 3 4
#define __POSIX2_THIS_VERSION 200809L
# 68 "/usr/include/unistd.h" 3 4
#define _POSIX2_VERSION __POSIX2_THIS_VERSION



#define _POSIX2_C_BIND __POSIX2_THIS_VERSION



#define _POSIX2_C_DEV __POSIX2_THIS_VERSION



#define _POSIX2_SW_DEV __POSIX2_THIS_VERSION



#define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION



#define _XOPEN_VERSION 700
# 98 "/usr/include/unistd.h" 3 4
#define _XOPEN_XCU_VERSION 4


#define _XOPEN_XPG2 1
#define _XOPEN_XPG3 1
#define _XOPEN_XPG4 1


#define _XOPEN_UNIX 1


#define _XOPEN_CRYPT 1



#define _XOPEN_ENH_I18N 1


#define _XOPEN_LEGACY 1
# 203 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 21 "/usr/include/bits/posix_opt.h" 3 4
#define _BITS_POSIX_OPT_H 1


#define _POSIX_JOB_CONTROL 1


#define _POSIX_SAVED_IDS 1


#define _POSIX_PRIORITY_SCHEDULING 200809L


#define _POSIX_SYNCHRONIZED_IO 200809L


#define _POSIX_FSYNC 200809L


#define _POSIX_MAPPED_FILES 200809L


#define _POSIX_MEMLOCK 200809L


#define _POSIX_MEMLOCK_RANGE 200809L


#define _POSIX_MEMORY_PROTECTION 200809L


#define _POSIX_CHOWN_RESTRICTED 0



#define _POSIX_VDISABLE '\0'


#define _POSIX_NO_TRUNC 1


#define _XOPEN_REALTIME 1


#define _XOPEN_REALTIME_THREADS 1


#define _XOPEN_SHM 1


#define _POSIX_THREADS 200809L


#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L


#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L


#define _POSIX_THREAD_ATTR_STACKSIZE 200809L


#define _POSIX_THREAD_ATTR_STACKADDR 200809L


#define _POSIX_THREAD_PRIO_INHERIT 200809L



#define _POSIX_THREAD_PRIO_PROTECT 200809L



#define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L


#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1



#define _POSIX_SEMAPHORES 200809L


#define _POSIX_REALTIME_SIGNALS 200809L


#define _POSIX_ASYNCHRONOUS_IO 200809L
#define _POSIX_ASYNC_IO 1

#define _LFS_ASYNCHRONOUS_IO 1

#define _POSIX_PRIORITIZED_IO 200809L


#define _LFS64_ASYNCHRONOUS_IO 1


#define _LFS_LARGEFILE 1
#define _LFS64_LARGEFILE 1
#define _LFS64_STDIO 1


#define _POSIX_SHARED_MEMORY_OBJECTS 200809L


#define _POSIX_CPUTIME 0


#define _POSIX_THREAD_CPUTIME 0


#define _POSIX_REGEXP 1


#define _POSIX_READER_WRITER_LOCKS 200809L


#define _POSIX_SHELL 1


#define _POSIX_TIMEOUTS 200809L


#define _POSIX_SPIN_LOCKS 200809L


#define _POSIX_SPAWN 200809L


#define _POSIX_TIMERS 200809L


#define _POSIX_BARRIERS 200809L


#define _POSIX_MESSAGE_PASSING 200809L


#define _POSIX_THREAD_PROCESS_SHARED 200809L


#define _POSIX_MONOTONIC_CLOCK 0


#define _POSIX_CLOCK_SELECTION 200809L


#define _POSIX_ADVISORY_INFO 200809L


#define _POSIX_IPV6 200809L


#define _POSIX_RAW_SOCKETS 200809L


#define _POSIX2_CHAR_TERM 200809L


#define _POSIX_SPORADIC_SERVER -1
#define _POSIX_THREAD_SPORADIC_SERVER -1


#define _POSIX_TRACE -1
#define _POSIX_TRACE_EVENT_FILTER -1
#define _POSIX_TRACE_INHERIT -1
#define _POSIX_TRACE_LOG -1


#define _POSIX_TYPED_MEMORY_OBJECTS -1
# 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



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 24 "/usr/include/bits/environments.h" 2 3 4
# 57 "/usr/include/bits/environments.h" 3 4
#define _POSIX_V7_LPBIG_OFFBIG -1
#define _POSIX_V6_LPBIG_OFFBIG -1
#define _XBS5_LPBIG_OFFBIG -1


#define _POSIX_V7_LP64_OFF64 1
#define _POSIX_V6_LP64_OFF64 1
#define _XBS5_LP64_OFF64 1
# 92 "/usr/include/bits/environments.h" 3 4
#define __ILP32_OFF32_CFLAGS "-m32"
#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
#define __ILP32_OFF32_LDFLAGS "-m32"
#define __ILP32_OFFBIG_LDFLAGS "-m32"
#define __LP64_OFF64_CFLAGS "-m64"
#define __LP64_OFF64_LDFLAGS "-m64"
# 208 "/usr/include/unistd.h" 2 3 4



#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2







typedef __ssize_t ssize_t;
#define __ssize_t_defined 


#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 228 "/usr/include/unistd.h" 2 3 4





typedef __gid_t gid_t;
#define __gid_t_defined 



typedef __uid_t uid_t;
#define __uid_t_defined 




typedef __off_t off_t;



#define __off_t_defined 


typedef __off64_t off64_t;
#define __off64_t_defined 



typedef __useconds_t useconds_t;
#define __useconds_t_defined 
# 268 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;
#define __intptr_t_defined 





typedef __socklen_t socklen_t;
#define __socklen_t_defined 





#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0


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





#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2




#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
# 331 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 342 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     throw ();






extern int close (int __fd);






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





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






extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
         __off_t __offset) ;
# 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,
#define _PC_LINK_MAX _PC_LINK_MAX
    _PC_MAX_CANON,
#define _PC_MAX_CANON _PC_MAX_CANON
    _PC_MAX_INPUT,
#define _PC_MAX_INPUT _PC_MAX_INPUT
    _PC_NAME_MAX,
#define _PC_NAME_MAX _PC_NAME_MAX
    _PC_PATH_MAX,
#define _PC_PATH_MAX _PC_PATH_MAX
    _PC_PIPE_BUF,
#define _PC_PIPE_BUF _PC_PIPE_BUF
    _PC_CHOWN_RESTRICTED,
#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
    _PC_NO_TRUNC,
#define _PC_NO_TRUNC _PC_NO_TRUNC
    _PC_VDISABLE,
#define _PC_VDISABLE _PC_VDISABLE
    _PC_SYNC_IO,
#define _PC_SYNC_IO _PC_SYNC_IO
    _PC_ASYNC_IO,
#define _PC_ASYNC_IO _PC_ASYNC_IO
    _PC_PRIO_IO,
#define _PC_PRIO_IO _PC_PRIO_IO
    _PC_SOCK_MAXBUF,
#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
    _PC_FILESIZEBITS,
#define _PC_FILESIZEBITS _PC_FILESIZEBITS
    _PC_REC_INCR_XFER_SIZE,
#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
    _PC_REC_MAX_XFER_SIZE,
#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
    _PC_REC_MIN_XFER_SIZE,
#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
    _PC_REC_XFER_ALIGN,
#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
    _PC_ALLOC_SIZE_MIN,
#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
    _PC_SYMLINK_MAX,
#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
    _PC_2_SYMLINKS
#define _PC_2_SYMLINKS _PC_2_SYMLINKS
  };


enum
  {
    _SC_ARG_MAX,
#define _SC_ARG_MAX _SC_ARG_MAX
    _SC_CHILD_MAX,
#define _SC_CHILD_MAX _SC_CHILD_MAX
    _SC_CLK_TCK,
#define _SC_CLK_TCK _SC_CLK_TCK
    _SC_NGROUPS_MAX,
#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
    _SC_OPEN_MAX,
#define _SC_OPEN_MAX _SC_OPEN_MAX
    _SC_STREAM_MAX,
#define _SC_STREAM_MAX _SC_STREAM_MAX
    _SC_TZNAME_MAX,
#define _SC_TZNAME_MAX _SC_TZNAME_MAX
    _SC_JOB_CONTROL,
#define _SC_JOB_CONTROL _SC_JOB_CONTROL
    _SC_SAVED_IDS,
#define _SC_SAVED_IDS _SC_SAVED_IDS
    _SC_REALTIME_SIGNALS,
#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
    _SC_PRIORITY_SCHEDULING,
#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
    _SC_TIMERS,
#define _SC_TIMERS _SC_TIMERS
    _SC_ASYNCHRONOUS_IO,
#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
    _SC_PRIORITIZED_IO,
#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
    _SC_SYNCHRONIZED_IO,
#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
    _SC_FSYNC,
#define _SC_FSYNC _SC_FSYNC
    _SC_MAPPED_FILES,
#define _SC_MAPPED_FILES _SC_MAPPED_FILES
    _SC_MEMLOCK,
#define _SC_MEMLOCK _SC_MEMLOCK
    _SC_MEMLOCK_RANGE,
#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
    _SC_MEMORY_PROTECTION,
#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
    _SC_MESSAGE_PASSING,
#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
    _SC_SEMAPHORES,
#define _SC_SEMAPHORES _SC_SEMAPHORES
    _SC_SHARED_MEMORY_OBJECTS,
#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
    _SC_AIO_LISTIO_MAX,
#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
    _SC_AIO_MAX,
#define _SC_AIO_MAX _SC_AIO_MAX
    _SC_AIO_PRIO_DELTA_MAX,
#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
    _SC_DELAYTIMER_MAX,
#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
    _SC_MQ_OPEN_MAX,
#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
    _SC_MQ_PRIO_MAX,
#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
    _SC_VERSION,
#define _SC_VERSION _SC_VERSION
    _SC_PAGESIZE,
#define _SC_PAGESIZE _SC_PAGESIZE
#define _SC_PAGE_SIZE _SC_PAGESIZE
    _SC_RTSIG_MAX,
#define _SC_RTSIG_MAX _SC_RTSIG_MAX
    _SC_SEM_NSEMS_MAX,
#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
    _SC_SEM_VALUE_MAX,
#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
    _SC_SIGQUEUE_MAX,
#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
    _SC_TIMER_MAX,
#define _SC_TIMER_MAX _SC_TIMER_MAX



    _SC_BC_BASE_MAX,
#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
    _SC_BC_DIM_MAX,
#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
    _SC_BC_SCALE_MAX,
#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
    _SC_BC_STRING_MAX,
#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
    _SC_COLL_WEIGHTS_MAX,
#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
    _SC_EQUIV_CLASS_MAX,
#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
    _SC_EXPR_NEST_MAX,
#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
    _SC_LINE_MAX,
#define _SC_LINE_MAX _SC_LINE_MAX
    _SC_RE_DUP_MAX,
#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
    _SC_CHARCLASS_NAME_MAX,
#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX

    _SC_2_VERSION,
#define _SC_2_VERSION _SC_2_VERSION
    _SC_2_C_BIND,
#define _SC_2_C_BIND _SC_2_C_BIND
    _SC_2_C_DEV,
#define _SC_2_C_DEV _SC_2_C_DEV
    _SC_2_FORT_DEV,
#define _SC_2_FORT_DEV _SC_2_FORT_DEV
    _SC_2_FORT_RUN,
#define _SC_2_FORT_RUN _SC_2_FORT_RUN
    _SC_2_SW_DEV,
#define _SC_2_SW_DEV _SC_2_SW_DEV
    _SC_2_LOCALEDEF,
#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF

    _SC_PII,
#define _SC_PII _SC_PII
    _SC_PII_XTI,
#define _SC_PII_XTI _SC_PII_XTI
    _SC_PII_SOCKET,
#define _SC_PII_SOCKET _SC_PII_SOCKET
    _SC_PII_INTERNET,
#define _SC_PII_INTERNET _SC_PII_INTERNET
    _SC_PII_OSI,
#define _SC_PII_OSI _SC_PII_OSI
    _SC_POLL,
#define _SC_POLL _SC_POLL
    _SC_SELECT,
#define _SC_SELECT _SC_SELECT
    _SC_UIO_MAXIOV,
#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
    _SC_IOV_MAX = _SC_UIO_MAXIOV,
#define _SC_IOV_MAX _SC_IOV_MAX
    _SC_PII_INTERNET_STREAM,
#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
    _SC_PII_INTERNET_DGRAM,
#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
    _SC_PII_OSI_COTS,
#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
    _SC_PII_OSI_CLTS,
#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
    _SC_PII_OSI_M,
#define _SC_PII_OSI_M _SC_PII_OSI_M
    _SC_T_IOV_MAX,
#define _SC_T_IOV_MAX _SC_T_IOV_MAX


    _SC_THREADS,
#define _SC_THREADS _SC_THREADS
    _SC_THREAD_SAFE_FUNCTIONS,
#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
    _SC_GETGR_R_SIZE_MAX,
#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
    _SC_GETPW_R_SIZE_MAX,
#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
    _SC_LOGIN_NAME_MAX,
#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
    _SC_TTY_NAME_MAX,
#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
    _SC_THREAD_DESTRUCTOR_ITERATIONS,
#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
    _SC_THREAD_KEYS_MAX,
#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
    _SC_THREAD_STACK_MIN,
#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
    _SC_THREAD_THREADS_MAX,
#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
    _SC_THREAD_ATTR_STACKADDR,
#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
    _SC_THREAD_ATTR_STACKSIZE,
#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
    _SC_THREAD_PRIORITY_SCHEDULING,
#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
    _SC_THREAD_PRIO_INHERIT,
#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
    _SC_THREAD_PRIO_PROTECT,
#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
    _SC_THREAD_PROCESS_SHARED,
#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED

    _SC_NPROCESSORS_CONF,
#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
    _SC_NPROCESSORS_ONLN,
#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
    _SC_PHYS_PAGES,
#define _SC_PHYS_PAGES _SC_PHYS_PAGES
    _SC_AVPHYS_PAGES,
#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
    _SC_ATEXIT_MAX,
#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
    _SC_PASS_MAX,
#define _SC_PASS_MAX _SC_PASS_MAX

    _SC_XOPEN_VERSION,
#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
    _SC_XOPEN_XCU_VERSION,
#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
    _SC_XOPEN_UNIX,
#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
    _SC_XOPEN_CRYPT,
#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
    _SC_XOPEN_ENH_I18N,
#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
    _SC_XOPEN_SHM,
#define _SC_XOPEN_SHM _SC_XOPEN_SHM

    _SC_2_CHAR_TERM,
#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
    _SC_2_C_VERSION,
#define _SC_2_C_VERSION _SC_2_C_VERSION
    _SC_2_UPE,
#define _SC_2_UPE _SC_2_UPE

    _SC_XOPEN_XPG2,
#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
    _SC_XOPEN_XPG3,
#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
    _SC_XOPEN_XPG4,
#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4

    _SC_CHAR_BIT,
#define _SC_CHAR_BIT _SC_CHAR_BIT
    _SC_CHAR_MAX,
#define _SC_CHAR_MAX _SC_CHAR_MAX
    _SC_CHAR_MIN,
#define _SC_CHAR_MIN _SC_CHAR_MIN
    _SC_INT_MAX,
#define _SC_INT_MAX _SC_INT_MAX
    _SC_INT_MIN,
#define _SC_INT_MIN _SC_INT_MIN
    _SC_LONG_BIT,
#define _SC_LONG_BIT _SC_LONG_BIT
    _SC_WORD_BIT,
#define _SC_WORD_BIT _SC_WORD_BIT
    _SC_MB_LEN_MAX,
#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
    _SC_NZERO,
#define _SC_NZERO _SC_NZERO
    _SC_SSIZE_MAX,
#define _SC_SSIZE_MAX _SC_SSIZE_MAX
    _SC_SCHAR_MAX,
#define _SC_SCHAR_MAX _SC_SCHAR_MAX
    _SC_SCHAR_MIN,
#define _SC_SCHAR_MIN _SC_SCHAR_MIN
    _SC_SHRT_MAX,
#define _SC_SHRT_MAX _SC_SHRT_MAX
    _SC_SHRT_MIN,
#define _SC_SHRT_MIN _SC_SHRT_MIN
    _SC_UCHAR_MAX,
#define _SC_UCHAR_MAX _SC_UCHAR_MAX
    _SC_UINT_MAX,
#define _SC_UINT_MAX _SC_UINT_MAX
    _SC_ULONG_MAX,
#define _SC_ULONG_MAX _SC_ULONG_MAX
    _SC_USHRT_MAX,
#define _SC_USHRT_MAX _SC_USHRT_MAX

    _SC_NL_ARGMAX,
#define _SC_NL_ARGMAX _SC_NL_ARGMAX
    _SC_NL_LANGMAX,
#define _SC_NL_LANGMAX _SC_NL_LANGMAX
    _SC_NL_MSGMAX,
#define _SC_NL_MSGMAX _SC_NL_MSGMAX
    _SC_NL_NMAX,
#define _SC_NL_NMAX _SC_NL_NMAX
    _SC_NL_SETMAX,
#define _SC_NL_SETMAX _SC_NL_SETMAX
    _SC_NL_TEXTMAX,
#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX

    _SC_XBS5_ILP32_OFF32,
#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
    _SC_XBS5_ILP32_OFFBIG,
#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
    _SC_XBS5_LP64_OFF64,
#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
    _SC_XBS5_LPBIG_OFFBIG,
#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG

    _SC_XOPEN_LEGACY,
#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
    _SC_XOPEN_REALTIME,
#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
    _SC_XOPEN_REALTIME_THREADS,
#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS

    _SC_ADVISORY_INFO,
#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
    _SC_BARRIERS,
#define _SC_BARRIERS _SC_BARRIERS
    _SC_BASE,
#define _SC_BASE _SC_BASE
    _SC_C_LANG_SUPPORT,
#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
    _SC_C_LANG_SUPPORT_R,
#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
    _SC_CLOCK_SELECTION,
#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
    _SC_CPUTIME,
#define _SC_CPUTIME _SC_CPUTIME
    _SC_THREAD_CPUTIME,
#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
    _SC_DEVICE_IO,
#define _SC_DEVICE_IO _SC_DEVICE_IO
    _SC_DEVICE_SPECIFIC,
#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
    _SC_DEVICE_SPECIFIC_R,
#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
    _SC_FD_MGMT,
#define _SC_FD_MGMT _SC_FD_MGMT
    _SC_FIFO,
#define _SC_FIFO _SC_FIFO
    _SC_PIPE,
#define _SC_PIPE _SC_PIPE
    _SC_FILE_ATTRIBUTES,
#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
    _SC_FILE_LOCKING,
#define _SC_FILE_LOCKING _SC_FILE_LOCKING
    _SC_FILE_SYSTEM,
#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
    _SC_MONOTONIC_CLOCK,
#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
    _SC_MULTI_PROCESS,
#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
    _SC_SINGLE_PROCESS,
#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
    _SC_NETWORKING,
#define _SC_NETWORKING _SC_NETWORKING
    _SC_READER_WRITER_LOCKS,
#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
    _SC_SPIN_LOCKS,
#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
    _SC_REGEXP,
#define _SC_REGEXP _SC_REGEXP
    _SC_REGEX_VERSION,
#define _SC_REGEX_VERSION _SC_REGEX_VERSION
    _SC_SHELL,
#define _SC_SHELL _SC_SHELL
    _SC_SIGNALS,
#define _SC_SIGNALS _SC_SIGNALS
    _SC_SPAWN,
#define _SC_SPAWN _SC_SPAWN
    _SC_SPORADIC_SERVER,
#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
    _SC_THREAD_SPORADIC_SERVER,
#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
    _SC_SYSTEM_DATABASE,
#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
    _SC_SYSTEM_DATABASE_R,
#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
    _SC_TIMEOUTS,
#define _SC_TIMEOUTS _SC_TIMEOUTS
    _SC_TYPED_MEMORY_OBJECTS,
#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
    _SC_USER_GROUPS,
#define _SC_USER_GROUPS _SC_USER_GROUPS
    _SC_USER_GROUPS_R,
#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
    _SC_2_PBS,
#define _SC_2_PBS _SC_2_PBS
    _SC_2_PBS_ACCOUNTING,
#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
    _SC_2_PBS_LOCATE,
#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
    _SC_2_PBS_MESSAGE,
#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
    _SC_2_PBS_TRACK,
#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
    _SC_SYMLOOP_MAX,
#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
    _SC_STREAMS,
#define _SC_STREAMS _SC_STREAMS
    _SC_2_PBS_CHECKPOINT,
#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT

    _SC_V6_ILP32_OFF32,
#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
    _SC_V6_ILP32_OFFBIG,
#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
    _SC_V6_LP64_OFF64,
#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
    _SC_V6_LPBIG_OFFBIG,
#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG

    _SC_HOST_NAME_MAX,
#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
    _SC_TRACE,
#define _SC_TRACE _SC_TRACE
    _SC_TRACE_EVENT_FILTER,
#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
    _SC_TRACE_INHERIT,
#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
    _SC_TRACE_LOG,
#define _SC_TRACE_LOG _SC_TRACE_LOG

    _SC_LEVEL1_ICACHE_SIZE,
#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
    _SC_LEVEL1_ICACHE_ASSOC,
#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
    _SC_LEVEL1_ICACHE_LINESIZE,
#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
    _SC_LEVEL1_DCACHE_SIZE,
#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
    _SC_LEVEL1_DCACHE_ASSOC,
#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
    _SC_LEVEL1_DCACHE_LINESIZE,
#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
    _SC_LEVEL2_CACHE_SIZE,
#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
    _SC_LEVEL2_CACHE_ASSOC,
#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
    _SC_LEVEL2_CACHE_LINESIZE,
#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
    _SC_LEVEL3_CACHE_SIZE,
#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
    _SC_LEVEL3_CACHE_ASSOC,
#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
    _SC_LEVEL3_CACHE_LINESIZE,
#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
    _SC_LEVEL4_CACHE_SIZE,
#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
    _SC_LEVEL4_CACHE_ASSOC,
#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
    _SC_LEVEL4_CACHE_LINESIZE,
#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE


    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#define _SC_IPV6 _SC_IPV6
    _SC_RAW_SOCKETS,
#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS

    _SC_V7_ILP32_OFF32,
#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32
    _SC_V7_ILP32_OFFBIG,
#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
    _SC_V7_LP64_OFF64,
#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64
    _SC_V7_LPBIG_OFFBIG,
#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG

    _SC_SS_REPL_MAX,
#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX

    _SC_TRACE_EVENT_NAME_MAX,
#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX
    _SC_TRACE_NAME_MAX,
#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX
    _SC_TRACE_SYS_MAX,
#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX
    _SC_TRACE_USER_EVENT_MAX,
#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX

    _SC_XOPEN_STREAMS,
#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS

    _SC_THREAD_ROBUST_PRIO_INHERIT,
#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT
    _SC_THREAD_ROBUST_PRIO_PROTECT
#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT
  };


enum
  {
    _CS_PATH,
#define _CS_PATH _CS_PATH

    _CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS

    _CS_GNU_LIBC_VERSION,
#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
    _CS_GNU_LIBPTHREAD_VERSION,
#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION

    _CS_V5_WIDTH_RESTRICTED_ENVS,
#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS

    _CS_V7_WIDTH_RESTRICTED_ENVS,
#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS

    _CS_LFS_CFLAGS = 1000,
#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
    _CS_LFS_LDFLAGS,
#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
    _CS_LFS_LIBS,
#define _CS_LFS_LIBS _CS_LFS_LIBS
    _CS_LFS_LINTFLAGS,
#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
    _CS_LFS64_CFLAGS,
#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
    _CS_LFS64_LDFLAGS,
#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
    _CS_LFS64_LIBS,
#define _CS_LFS64_LIBS _CS_LFS64_LIBS
    _CS_LFS64_LINTFLAGS,
#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS

    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
    _CS_XBS5_ILP32_OFF32_LDFLAGS,
#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
    _CS_XBS5_ILP32_OFF32_LIBS,
#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
    _CS_XBS5_ILP32_OFFBIG_LIBS,
#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
    _CS_XBS5_LP64_OFF64_CFLAGS,
#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
    _CS_XBS5_LP64_OFF64_LDFLAGS,
#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
    _CS_XBS5_LP64_OFF64_LIBS,
#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
    _CS_XBS5_LP64_OFF64_LINTFLAGS,
#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
    _CS_XBS5_LPBIG_OFFBIG_LIBS,
#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS

    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
    _CS_POSIX_V6_ILP32_OFF32_LIBS,
#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
    _CS_POSIX_V6_LP64_OFF64_LIBS,
#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS

    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
    _CS_POSIX_V7_ILP32_OFF32_LIBS,
#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
    _CS_POSIX_V7_LP64_OFF64_LIBS,
#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS
    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _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)));







#define __need_getopt 
# 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
}



#undef __need_getopt
# 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 ();




extern int truncate (__const char *__file, __off_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1010 "/usr/include/unistd.h" 3 4
extern int truncate64 (__const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1020 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
# 1030 "/usr/include/unistd.h" 3 4
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 ();
# 1078 "/usr/include/unistd.h" 3 4
#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3


extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1094 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1104 "/usr/include/unistd.h" 3 4
#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
# 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
}
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3

typedef pthread_t __gthread_t;
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
typedef pthread_cond_t __gthread_cond_t;
typedef struct timespec __gthread_time_t;



#define __GTHREAD_HAS_COND 1

#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT



#define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP



#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
#define __GTHREAD_TIME_INIT {0,0}



#define __gthrw_pragma(pragma) 

#define __gthrw2(name,name2,type) static __typeof(type) name __attribute__ ((__weakref__(#name2))); __gthrw_pragma(weak type)


#define __gthrw_(name) __gthrw_ ## name






#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));

static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));

static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));


static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));


static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));

static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));


static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-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;
}
# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return __gthrw_pthread_create (__threadid, __null, __func, __args);
}

static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return __gthrw_pthread_join (__threadid, __value_ptr);
}

static inline int
__gthread_detach (__gthread_t __threadid)
{
  return __gthrw_pthread_detach (__threadid);
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return __gthrw_pthread_equal (__t1, __t2);
}

static inline __gthread_t
__gthread_self (void)
{
  return __gthrw_pthread_self ();
}

static inline int
__gthread_yield (void)
{
  return __gthrw_sched_yield ();
}

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return __gthrw_pthread_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return __gthrw_pthread_key_create (__key, __dtor);
}

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

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

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

static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_destroy (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_trylock (__mutex);
  else
    return 0;
}



static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
      const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}



static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_unlock (__mutex);
  else
    return 0;
}
# 818 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-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_timedlock (__gthread_recursive_mutex_t *__mutex,
         const __gthread_time_t *__abs_timeout)
{
  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}



static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_unlock (__mutex);
}

static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_broadcast (__cond);
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_signal (__cond);
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return __gthrw_pthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
     const __gthread_time_t *__abs_timeout)
{
  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
          __gthread_recursive_mutex_t *__mutex)
{
  return __gthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
        __gthread_recursive_mutex_t *__mutex,
        const __gthread_time_t *__abs_timeout)
{
  return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
  return __gthrw_pthread_cond_destroy (__cond);
}
# 163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 2 3







#pragma GCC visibility pop
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/atomicity.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
#define _GLIBCXX_ATOMIC_WORD_H 1

typedef int _Atomic_word;
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/atomicity.h" 2 3

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






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

  static inline void
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __sync_fetch_and_add(__mem, __val); }
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/atomicity.h" 3
  static inline _Atomic_word
  __exchange_and_add_single(_Atomic_word* __mem, int __val)
  {
    _Atomic_word __result = *__mem;
    *__mem += __val;
    return __result;
  }

  static inline void
  __atomic_add_single(_Atomic_word* __mem, int __val)
  { *__mem += __val; }

  static inline _Atomic_word
  __attribute__ ((__unused__))
  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      return __exchange_and_add(__mem, __val);
    else
      return __exchange_and_add_single(__mem, __val);



  }

  static inline void
  __attribute__ ((__unused__))
  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      __atomic_add(__mem, __val);
    else
      __atomic_add_single(__mem, __val);



  }

}





#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")


#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
#define _LOCALE_CLASSES_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 3
#define _GLIBCXX_STRING 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/allocator.h" 1 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/allocator.h" 3
#define _ALLOCATOR_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
#define _GLIBCXX_CXX_ALLOCATOR_H 1


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/new_allocator.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/new_allocator.h" 3
#define _NEW_ALLOCATOR_H 1

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/new" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/new" 3
#define _NEW 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/new" 2 3


#pragma GCC visibility push(default)

extern "C++" {

namespace std
{






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



    virtual ~bad_alloc() throw();


    virtual const char* what() const throw();
  };

  struct nothrow_t { };

  extern const nothrow_t nothrow;



  typedef void (*new_handler)();



  new_handler set_new_handler(new_handler) throw();
}
# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/new_allocator.h" 2 3



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

  using std::size_t;
  using std::ptrdiff_t;
# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/new_allocator.h" 3
  template<typename _Tp>
    class new_allocator
    {
    public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;
      typedef _Tp value_type;

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

      new_allocator() throw() { }

      new_allocator(const new_allocator&) throw() { }

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

      ~new_allocator() throw() { }

      pointer
      address(reference __x) const { return &__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((void *)__p) _Tp(__val); }
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ext/new_allocator.h" 3
      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/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
#define __glibcxx_base_allocator __gnu_cxx::new_allocator
# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/allocator.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/allocator.h" 3
  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; };
    };
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/allocator.h" 3
  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {
   public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;
      typedef _Tp value_type;

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

      allocator() throw() { }

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

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

      ~allocator() throw() { }


    };

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

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

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

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





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



#undef __glibcxx_base_allocator


  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_swap
    { static void _S_do_it(_Alloc&, _Alloc&) { } };

  template<typename _Alloc>
    struct __alloc_swap<_Alloc, false>
    {
      static void
      _S_do_it(_Alloc& __one, _Alloc& __two)
      {

 if (__one != __two)
   swap(__one, __two);
      }
    };


  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_neq
    {
      static bool
      _S_do_it(const _Alloc&, const _Alloc&)
      { return false; }
    };

  template<typename _Alloc>
    struct __alloc_neq<_Alloc, false>
    {
      static bool
      _S_do_it(const _Alloc& __one, const _Alloc& __two)
      { return __one != __two; }
    };

}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream_insert.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream_insert.h" 3
#define _OSTREAM_INSERT_H 1

       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream_insert.h" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cxxabi-forced.h" 1 3
# 27 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cxxabi-forced.h" 3
#define _CXXABI_FORCED_H 1

#pragma GCC visibility push(default)


namespace __cxxabiv1
{







  class __forced_unwind
  {
    virtual ~__forced_unwind() throw();
    virtual void __pure_dummy() = 0;
  };
}


#pragma GCC visibility pop
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream_insert.h" 2 3

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

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
      const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
      if (__put != __n)
 __out.setstate(__ios_base::badbit);
    }

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const _CharT __c = __out.fill();
      for (; __n > 0; --__n)
 {
   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
   if (_Traits::eq_int_type(__put, _Traits::eof()))
     {
       __out.setstate(__ios_base::badbit);
       break;
     }
 }
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
       const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       if (__w > __n)
  {
    const bool __left = ((__out.flags()
     & __ios_base::adjustfield)
           == __ios_base::left);
    if (!__left)
      __ostream_fill(__out, __w - __n);
    if (__out.good())
      __ostream_write(__out, __s, __n);
    if (__left && __out.good())
      __ostream_fill(__out, __w - __n);
  }
       else
  __ostream_write(__out, __s, __n);
       __out.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(__ios_base::badbit); }
 }
      return __out;
    }





  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);


  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
          streamsize);



}
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 2 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
#define _STL_FUNCTION_H 1

namespace std __attribute__ ((__visibility__ ("default"))) {
# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    struct unary_function
    {
      typedef _Arg argument_type;


      typedef _Result result_type;
    };




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


      typedef _Arg2 second_argument_type;
      typedef _Result result_type;
    };
# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


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


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


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


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


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
# 198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


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


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


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


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


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };
# 262 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


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


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };




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

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

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Predicate>
    class unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }

      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template<typename _Predicate>
    class binary_negate
    : public binary_function<typename _Predicate::first_argument_type,
        typename _Predicate::second_argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }

      bool
      operator()(const typename _Predicate::first_argument_type& __x,
   const typename _Predicate::second_argument_type& __y) const
      { return !_M_pred(__x, __y); }
    };


  template<typename _Predicate>
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    class pointer_to_unary_function : public unary_function<_Arg, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    };


  template<typename _Arg, typename _Result>
    inline pointer_to_unary_function<_Arg, _Result>
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function<_Arg, _Result>(__x); }


  template<typename _Arg1, typename _Arg2, typename _Result>
    class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    };


  template<typename _Arg1, typename _Arg2, typename _Result>
    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }


  template<typename _Tp>
    struct _Identity : public unary_function<_Tp,_Tp>
    {
      _Tp&
      operator()(_Tp& __x) const
      { return __x; }

      const _Tp&
      operator()(const _Tp& __x) const
      { return __x; }
    };

  template<typename _Pair>
    struct _Select1st : public unary_function<_Pair,
           typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

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

  template<typename _Pair>
    struct _Select2nd : public unary_function<_Pair,
           typename _Pair::second_type>
    {
      typename _Pair::second_type&
      operator()(_Pair& __x) const
      { return __x.second; }

      const typename _Pair::second_type&
      operator()(const _Pair& __x) const
      { return __x.second; }
    };
# 523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 3
  template<typename _Ret, typename _Tp>
    class mem_fun_t : public unary_function<_Tp*, _Ret>
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp>
    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
  };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp>
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

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

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

  template<typename _Ret, typename _Tp>
    inline const_mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }



}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/binders.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/binders.h" 3
#define _GLIBCXX_BINDERS_H 1

namespace std __attribute__ ((__visibility__ ("default"))) {
# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/binders.h" 3
  template<typename _Operation>
    class binder1st
    : public unary_function<typename _Operation::second_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::first_argument_type value;

    public:
      binder1st(const _Operation& __x,
  const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }



      typename _Operation::result_type
      operator()(typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }
    } ;


  template<typename _Operation, typename _Tp>
    inline binder1st<_Operation>
    bind1st(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
    }


  template<typename _Operation>
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::second_argument_type value;

    public:
      binder2nd(const _Operation& __x,
  const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }



      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }
    } ;


  template<typename _Operation, typename _Tp>
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    }


}
# 713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_function.h" 2 3
# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
#define _BASIC_STRING_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/initializer_list" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/initializer_list" 3
#define __CXX_INITIALIZER_LIST 
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 103 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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_dispatch(&this->_M_refcount,
             -1) <= 0)
       _M_destroy(__a);
 }

 void
 _M_destroy(const _Alloc&) throw();

 _CharT*
 _M_refcopy() throw()
 {

   if (__builtin_expect(this != &_S_empty_rep(), false))

            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
   return _M_refdata();
 }

 _CharT*
 _M_clone(const _Alloc&, size_type __res = 0);
      };


      struct _Alloc_hider : _Alloc
      {
 _Alloc_hider(_CharT* __dat, const _Alloc& __a)
 : _Alloc(__a), _M_p(__dat) { }

 _CharT* _M_p;
      };

    public:




      static const size_type npos = static_cast<size_type>(-1);

    private:

      mutable _Alloc_hider _M_dataplus;

      _CharT*
      _M_data() const
      { return _M_dataplus._M_p; }

      _CharT*
      _M_data(_CharT* __p)
      { return (_M_dataplus._M_p = __p); }

      _Rep*
      _M_rep() const
      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }



      iterator
      _M_ibegin() const
      { return iterator(_M_data()); }

      iterator
      _M_iend() const
      { return iterator(_M_data() + this->size()); }

      void
      _M_leak()
      {
 if (!_M_rep()->_M_is_leaked())
   _M_leak_hard();
      }

      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range((__s));
 return __pos;
      }

      void
      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error((__s));
      }


      size_type
      _M_limit(size_type __pos, size_type __off) const
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }


      bool
      _M_disjunct(const _CharT* __s) const
      {
 return (less<const _CharT*>()(__s, _M_data())
  || less<const _CharT*>()(_M_data() + this->size(), __s));
      }



      static void
      _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::copy(__d, __s, __n);
      }

      static void
      _M_move(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::move(__d, __s, __n);
      }

      static void
      _M_assign(_CharT* __d, size_type __n, _CharT __c)
      {
 if (__n == 1)
   traits_type::assign(*__d, __c);
 else
   traits_type::assign(__d, __n, __c);
      }



      template<class _Iterator>
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
   for (; __k1 != __k2; ++__k1, ++__p)
     traits_type::assign(*__p, *__k1);
 }

      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
      { _M_copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      { _M_copy(__p, __k1, __k2 - __k1); }

      static int
      _S_compare(size_type __n1, size_type __n2)
      {
 const difference_type __d = difference_type(__n1 - __n2);

 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
   return __gnu_cxx::__numeric_traits<int>::__max;
 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
   return __gnu_cxx::__numeric_traits<int>::__min;
 else
   return int(__d);
      }

      void
      _M_mutate(size_type __pos, size_type __len1, size_type __len2);

      void
      _M_leak_hard();

      static _Rep&
      _S_empty_rep()
      { return _Rep::_S_empty_rep(); }

    public:







      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);
# 459 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string(_InputIterator __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc());




      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }





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





      basic_string&
      operator=(const _CharT* __s)
      { return this->assign(__s); }
# 523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 548 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      iterator
      begin()
      {
 _M_leak();
 return iterator(_M_data());
      }





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





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





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






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






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






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






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

    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; }
# 647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 660 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }





      size_type
      capacity() const
      { return _M_rep()->_M_capacity; }
# 689 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 717 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 734 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {

 ;

 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 755 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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];
      }
# 774 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 830 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str);
# 845 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 877 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c);
# 899 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
# 938 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)); }
# 954 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 966 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return this->assign(__s, traits_type::length(__s));
      }
# 982 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 994 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
# 1022 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }
# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      template<class _InputIterator>
        void
        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }
# 1065 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1087 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)); }
# 1110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 1128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->insert(__pos, __s, traits_type::length(__s));
      }
# 1151 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 1168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      iterator
      insert(iterator __p, _CharT __c)
      {
 ;
 const size_type __pos = __p - _M_ibegin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 _M_rep()->_M_set_leaked();
 return iterator(_M_data() + __pos);
      }
# 1192 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 1208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      iterator
      erase(iterator __position)
      {
 ;

 const size_type __pos = __position - _M_ibegin();
 _M_mutate(__pos, size_type(1), size_type(0));
 _M_rep()->_M_set_leaked();
 return iterator(_M_data() + __pos);
      }
# 1228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 iterator(_M_data() + __pos);
      }
# 1255 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1277 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)); }
# 1301 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2);
# 1320 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1343 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 1361 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
      }
# 1400 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1421 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
      }
# 1443 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
      }
# 1518 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
    private:
      template<class _Integer>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
       _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
       _InputIterator __k2, __false_type);

      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c);

      basic_string&
      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
        size_type __n2);



      template<class _InIterator>
        static _CharT*
        _S_construct_aux(_InIterator __beg, _InIterator __end,
    const _Alloc& __a, __false_type)
 {
          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
 }



      template<class _Integer>
        static _CharT*
        _S_construct_aux(_Integer __beg, _Integer __end,
    const _Alloc& __a, __true_type)
        { return _S_construct(static_cast<size_type>(__beg), __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:
# 1594 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1604 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1614 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 1646 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1673 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1690 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const;
# 1703 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1718 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1731 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1748 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const;
# 1761 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1776 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1789 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1808 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }
# 1822 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1837 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1850 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1869 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }
# 1883 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1898 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const;
# 1912 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1929 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;
# 1942 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 1958 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const;
# 1971 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
      }
# 1988 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;
# 2003 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2021 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }
# 2051 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2075 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 2093 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 2116 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2141 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()) { }
# 2162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT>
    inline
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
    operator==(const basic_string<_CharT>& __lhs,
        const basic_string<_CharT>& __rhs)
    { return (__lhs.size() == __rhs.size()
       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
          __lhs.size())); }







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







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }
# 2279 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return !(__lhs == __rhs); }







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







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return !(__lhs == __rhs); }
# 2316 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 2353 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 2390 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 2427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 2464 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
# 2499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const basic_string<_CharT, _Traits, _Alloc>& __str)
    {


      return __ostream_insert(__os, __str.data(), __str.size());
    }
# 2522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
# 2539 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return getline(__is, __str, __is.widen('\n')); }

  template<>
    basic_istream<char>&
    getline(basic_istream<char>& __in, basic_string<char>& __str,
     char __delim);


  template<>
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
     wchar_t __delim);


}
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.tcc" 1 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.tcc" 3
#define _BASIC_STRING_TCC 1

       
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.tcc" 3



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

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;

  template<typename _CharT, typename _Traits, typename _Alloc>
    const _CharT
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_terminal = _CharT();

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;



  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
      sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     input_iterator_tag)
      {

 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();


 _CharT __buf[128];
 size_type __len = 0;
 while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
   {
     __buf[__len++] = *__beg;
     ++__beg;
   }
 _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
 _M_copy(__r->_M_refdata(), __buf, __len);
 try
   {
     while (__beg != __end)
       {
  if (__len == __r->_M_capacity)
    {

      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
      _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
      __r->_M_destroy(__a);
      __r = __another;
    }
  __r->_M_refdata()[__len++] = *__beg;
  ++__beg;
       }
   }
 catch(...)
   {
     __r->_M_destroy(__a);
     throw;
   }
 __r->_M_set_length_and_sharable(__len);
 return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     forward_iterator_tag)
      {

 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();


 if (__builtin_expect(__gnu_cxx::__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)
    { }
# 241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    assign(const basic_string& __str)
    {
      if (_M_rep() != __str._M_rep())
 {

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

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

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

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

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

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

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

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

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

   template<typename _CharT, typename _Traits, typename _Alloc>
     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"));
# 555 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_string.tcc" 3
      const size_type __pagesize = 4096;
      const size_type __malloc_header_size = 4 * sizeof(void*);







      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 __capacity = 2 * __old_capacity;




      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);

      const size_type __adj_size = __size + __malloc_header_size;
      if (__adj_size > __pagesize && __capacity > __old_capacity)
 {
   const size_type __extra = __pagesize - __adj_size % __pagesize;
   __capacity += __extra / sizeof(_CharT);

   if (__capacity > _S_max_size)
     __capacity = _S_max_size;
   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 }



      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
      _Rep *__p = new (__place) _Rep;
      __p->_M_capacity = __capacity;







      __p->_M_set_sharable();
      return __p;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_clone(const _Alloc& __alloc, size_type __res)
    {

      const size_type __requested_cap = this->_M_length + __res;
      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
      __alloc);
      if (this->_M_length)
 _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);

      __r->_M_set_length_and_sharable(this->_M_length);
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    resize(size_type __n, _CharT __c)
    {
      const size_type __size = this->size();
      _M_check_length(__size, __n, "basic_string::resize");
      if (__size < __n)
 this->append(__n - __size, __c);
      else if (__n < __size)
 this->erase(__n);

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
     _InputIterator __k2, __false_type)
      {
 const basic_string __s(__k1, __k2);
 const size_type __n1 = __i2 - __i1;
 _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
 return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
          __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     _CharT __c)
    {
      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
      _M_mutate(__pos1, __n1, __n2);
      if (__n2)
 _M_assign(_M_data() + __pos1, __n2, __c);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
      size_type __n2)
    {
      _M_mutate(__pos1, __n1, __n2);
      if (__n2)
 _M_copy(_M_data() + __pos1, __s, __n2);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      ;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      const __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __len);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str;
      const __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
      ;
      if (__n)
 _M_copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      const _CharT* __data = _M_data();

      if (__n == 0)
 return __pos <= __size ? __pos : npos;

      if (__n <= __size)
 {
   for (; __pos <= __size - __n; ++__pos)
     if (traits_type::eq(__data[__pos], __s[0])
  && traits_type::compare(__data + __pos + 1,
     __s + 1, __n - 1) == 0)
       return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const
    {
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const size_type __n = __size - __pos;
   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
   if (__p)
     __ret = __p - __data;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__size - __n), __pos);
   const _CharT* __data = _M_data();
   do
     {
       if (traits_type::compare(__data + __pos, __s, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      for (; __n && __pos < this->size(); ++__pos)
 {
   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(_M_data()[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n, const basic_string& __str) const
    {
      _M_check(__pos, "basic_string::compare");
      __n = _M_limit(__pos, __n);
      const size_type __osize = __str.size();
      const size_type __len = std::min(__n, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
 __r = _S_compare(__n, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos1, size_type __n1, const basic_string& __str,
     size_type __pos2, size_type __n2) const
    {
      _M_check(__pos1, "basic_string::compare");
      __str._M_check(__pos2, "basic_string::compare");
      __n1 = _M_limit(__pos1, __n1);
      __n2 = __str._M_limit(__pos2, __n2);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos1,
         __str.data() + __pos2, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      ;
      const size_type __size = this->size();
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__size, __osize);
      int __r = traits_type::compare(_M_data(), __s, __len);
      if (!__r)
 __r = _S_compare(__size, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__n1, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s,
     size_type __n2) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;
      typedef ctype<_CharT> __ctype_type;
      typedef typename __ctype_type::ctype_base __ctype_base;

      __size_type __extracted = 0;
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(__ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {
       __str.erase();
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __in.rdbuf()->sbumpc();
  }
       else
  __err |= __ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }





  extern template class basic_string<char>;
  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);


  extern template class basic_string<wchar_t>;
  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);



}
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/string" 2 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 2 3


namespace std __attribute__ ((__visibility__ ("default"))) {
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
# 116 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    locale() throw();
# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    string
    name() const;
# 223 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw ();







    bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }
# 251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 302 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
  };
# 335 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 366 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
    void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

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

    facet(const facet&);

    facet&
    operator=(const facet&);
  };
# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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[];

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

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

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      if (_M_names[1])

 for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, const facet*);

    template<typename _Facet>
      void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    void
    _M_install_cache(const facet*, size_t);
  };
# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();
# 586 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);
# 603 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
  template<typename _CharT>
    class collate : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_collate;

    public:

      static locale::id id;
# 630 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 644 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 680 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 694 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const;

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const;

  protected:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 723 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 739 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 752 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 3
      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const;

  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 (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_collate);
     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
   }
      }

    protected:
      virtual
      ~collate_byname() { }
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.tcc" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.tcc" 3
#define _LOCALE_CLASSES_TCC 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.tcc" 3

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

  template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      try
 { _M_impl->_M_install_facet(&_Facet::id, __f); }
      catch(...)
 {
   _M_impl->_M_remove_reference();
   throw;
 }
      delete [] _M_impl->_M_names[0];
      _M_impl->_M_names[0] = 0;
    }

  template<typename _Facet>
    locale
    locale::
    combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }


  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size

       && dynamic_cast<const _Facet*>(__facets[__i]));



    }

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
        __throw_bad_cast();

      return dynamic_cast<const _Facet&>(*__facets[__i]);



    }



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
    { 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 __ret;


      const string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      _CharT* __c = new _CharT[__len];

      try
 {



   for (;;)
     {

       size_t __res = _M_transform(__c, __p, __len);


       if (__res >= __len)
  {
    __len = __res + 1;
    delete [] __c, __c = 0;
    __c = new _CharT[__len];
    __res = _M_transform(__c, __p, __len);
  }

       __ret.append(__c, __res);
       __p += char_traits<_CharT>::length(__p);
       if (__p == __pend)
  break;

       __p++;
       __ret.push_back(_CharT());
     }
 }
      catch(...)
 {
   delete [] __c;
   throw;
 }

      delete [] __c;

      return __ret;
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val =
   *__lo + ((__val << 7)
     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
    __digits - 7)));
      return static_cast<long>(__val);
    }





  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);


  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);



}
# 810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_classes.h" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 2 3






#define _IOS_BASE_SEEK_CUR 1
#define _IOS_BASE_SEEK_END 2


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





  enum _Ios_Fmtflags
    {
      _S_boolalpha = 1L << 0,
      _S_dec = 1L << 1,
      _S_fixed = 1L << 2,
      _S_hex = 1L << 3,
      _S_internal = 1L << 4,
      _S_left = 1L << 5,
      _S_oct = 1L << 6,
      _S_right = 1L << 7,
      _S_scientific = 1L << 8,
      _S_showbase = 1L << 9,
      _S_showpoint = 1L << 10,
      _S_showpos = 1L << 11,
      _S_skipws = 1L << 12,
      _S_unitbuf = 1L << 13,
      _S_uppercase = 1L << 14,
      _S_adjustfield = _S_left | _S_right | _S_internal,
      _S_basefield = _S_dec | _S_oct | _S_hex,
      _S_floatfield = _S_scientific | _S_fixed,
      _S_ios_fmtflags_end = 1L << 16
    };

  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Fmtflags&
  operator|=(_Ios_Fmtflags& __a, _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
    };
# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    };
# 263 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    typedef void (*event_callback) (event, ios_base&, int);
# 456 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    void
    register_callback(event_callback __fn, int __index);

  protected:




    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;




    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
       _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }


      int
      _M_remove_reference()
      { return __gnu_cxx::__exchange_and_add_dispatch(&_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;
    };






    fmtflags
    flags() const
    { return _M_flags; }
# 565 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 581 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 598 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    void
    unsetf(fmtflags __mask)
    { _M_flags &= ~__mask; }
# 624 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    streamsize
    precision() const
    { return _M_precision; }






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







    streamsize
    width() const
    { return _M_width; }






    streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc);
# 698 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 709 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 765 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ios_base.h" 3
    void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 782 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
  }

}

#undef _IOS_BASE_SEEK_CUR
#undef _IOS_BASE_SEEK_END
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
#define _GLIBXX_STREAMBUF 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 113 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;




      typedef basic_streambuf<char_type, traits_type> __streambuf_type;


      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);

      template<bool _IsMove, typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
        __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
      istreambuf_iterator<_CharT2> >::__type
        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
     basic_string<_CharT2, _Traits2, _Alloc>&);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    protected:
# 179 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()
      { }
# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      locale
      pubimbue(const locale &__loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 220 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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(); }
# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 292 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 333 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 347 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 372 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 439 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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())
      { }
# 457 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 484 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 504 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 520 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 530 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 551 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual void
      imbue(const locale&)
      { }
# 566 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)); }
# 589 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual int
      sync() { return 0; }
# 624 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 640 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 662 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 699 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 717 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 742 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }



    public:
# 757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 3
      void
      stossc()
      {
 if (this->gptr() < this->egptr())
   this->gbump(1);
 else
   this->uflow();
      }


    private:


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

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


  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
     basic_streambuf<char>* __sbout, bool& __ineof);

  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
     basic_streambuf<wchar_t>* __sbout, bool& __ineof);


}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf.tcc" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf.tcc" 3
#define _STREAMBUF_TCC 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf.tcc" 3

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

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->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_eof(basic_streambuf<_CharT, _Traits>* __sbin,
     basic_streambuf<_CharT, _Traits>* __sbout,
     bool& __ineof)
    {
      streamsize __ret = 0;
      __ineof = true;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   __c = __sbout->sputc(_Traits::to_char_type(__c));
   if (_Traits::eq_int_type(__c, _Traits::eof()))
     {
       __ineof = false;
       break;
     }
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    inline streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      bool __ineof;
      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
    }





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


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



}
# 797 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/streambuf" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
#define _BASIC_IOS_H 1

       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
#define _LOCALE_FACETS_H 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwctype" 3




# 1 "/usr/include/wctype.h" 1 3 4
# 30 "/usr/include/wctype.h" 3 4
#define _WCTYPE_H 1


#define __need_wint_t 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wint_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 35 "/usr/include/wctype.h" 2 3 4







#undef __need_iswxxx





#define __iswxxx_defined 1




typedef unsigned long int wctype_t;

# 65 "/usr/include/wctype.h" 3 4
#define _ISwbit(bit) ((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))






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



}
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cwctype" 2 3



#define _GLIBCXX_CWCTYPE 1


#undef iswalnum
#undef iswalpha

#undef iswblank

#undef iswcntrl
#undef iswctype
#undef iswdigit
#undef iswgraph
#undef iswlower
#undef iswprint
#undef iswpunct
#undef iswspace
#undef iswupper
#undef iswxdigit
#undef towctrans
#undef towlower
#undef towupper
#undef wctrans
#undef wctype



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

  using ::wctrans_t;
  using ::wctype_t;
  using ::wint_t;

  using ::iswalnum;
  using ::iswalpha;

  using ::iswblank;

  using ::iswcntrl;
  using ::iswctype;
  using ::iswdigit;
  using ::iswgraph;
  using ::iswlower;
  using ::iswprint;
  using ::iswpunct;
  using ::iswspace;
  using ::iswupper;
  using ::iswxdigit;
  using ::towctrans;
  using ::towlower;
  using ::towupper;
  using ::wctrans;
  using ::wctype;

}
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cctype" 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {


  struct ctype_base
  {

    typedef const int* __to_type;



    typedef unsigned short mask;
    static const mask upper = _ISupper;
    static const mask lower = _ISlower;
    static const mask alpha = _ISalpha;
    static const mask digit = _ISdigit;
    static const mask xdigit = _ISxdigit;
    static const mask space = _ISspace;
    static const mask print = _ISprint;
    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
    static const mask cntrl = _IScntrl;
    static const mask punct = _ISpunct;
    static const mask alnum = _ISalpha | _ISdigit;
  };

}
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf_iterator.h" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf_iterator.h" 3
#define _STREAMBUF_ITERATOR_H 1

       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/streambuf_iterator.h" 3




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



  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
        _CharT*, _CharT&>
    {
    public:



      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
                      ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

      template<bool _IsMove, typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
               istreambuf_iterator<_CharT2> >::__type
 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

    private:







      mutable streambuf_type* _M_sbuf;
      mutable int_type _M_c;

    public:

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


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


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




      char_type
      operator*() const
      {







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


      istreambuf_iterator&
      operator++()
      {
 ;


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


      istreambuf_iterator
      operator++(int)
      {
 ;



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





      bool
      equal(const istreambuf_iterator& __b) const
      { return _M_at_eof() == __b._M_at_eof(); }

    private:
      int_type
      _M_get() const
      {
 const int_type __eof = traits_type::eof();
 int_type __ret = __eof;
 if (_M_sbuf)
   {
     if (!traits_type::eq_int_type(_M_c, __eof))
       __ret = _M_c;
     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
            __eof))
       _M_c = __ret;
     else
       _M_sbuf = 0;
   }
 return __ret;
      }

      bool
      _M_at_eof() const
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(_M_get(), __eof);
      }
    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }


  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:



      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
                      ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:

      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


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


      ostreambuf_iterator&
      operator++(int)
      { return *this; }


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


      bool
      failed() const throw()
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
                           ostreambuf_iterator<_CharT> >::__type
    copy(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last,
  ostreambuf_iterator<_CharT> __result)
    {
      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 {
   bool __ineof;
   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
   if (!__ineof)
     __result._M_failed = true;
 }
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
            ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(_CharT* __first, _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(const _CharT* __first, const _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
            _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT> __first,
     istreambuf_iterator<_CharT> __last, _CharT* __result)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
       const streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    traits_type::copy(__result, __sb->gptr(), __n);
    __sb->gbump(__n);
    __result += __n;
    __c = __sb->underflow();
  }
       else
  {
    *__result++ = traits_type::to_char_type(__c);
    __c = __sb->snextc();
  }
     }
 }
      return __result;
    }

  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
          istreambuf_iterator<_CharT> >::__type
    find(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last, const _CharT& __val)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   const int_type __ival = traits_type::to_int_type(__val);
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof())
   && !traits_type::eq_int_type(__c, __ival))
     {
       streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    const _CharT* __p = traits_type::find(__sb->gptr(),
       __n, __val);
    if (__p)
      __n = __p - __sb->gptr();
    __sb->gbump(__n);
    __c = __sb->sgetc();
  }
       else
  __c = __sb->snextc();
     }

   if (!traits_type::eq_int_type(__c, traits_type::eof()))
     __first._M_c = __c;
   else
     __first._M_sbuf = 0;
 }
      return __first;
    }

}
# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3

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



#define _GLIBCXX_NUM_FACETS 28







  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, streamsize __newlen, streamsize __oldlen);
    };






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
 *__s = __ws[__j];
      return __s;
    }
# 143 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 161 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 253 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 268 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 285 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 304 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 323 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
       char __dfault, char *__to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }
# 370 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 389 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 445 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const = 0;
# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 478 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const = 0;
# 495 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const = 0;
# 535 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi,
        char_type* __dest) const = 0;
# 557 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const = 0;
# 581 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    };
# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 673 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
  template<>
    class ctype<char> : public locale::facet, public ctype_base
    {
    public:


      typedef char char_type;

    protected:

      __c_locale _M_c_locale_ctype;
      bool _M_del;
      __to_type _M_toupper;
      __to_type _M_tolower;
      const mask* _M_table;
      mutable char _M_widen_ok;
      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow_ok;


    public:

      static locale::id id;

      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 710 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 723 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 736 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 751 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 765 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 794 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 811 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 844 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 864 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      {
 if (_M_widen_ok)
   return _M_widen[static_cast<unsigned char>(__c)];
 this->_M_widen_init();
 return this->do_widen(__c);
      }
# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok)
   _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 922 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      {
 if (_M_narrow[static_cast<unsigned char>(__c)])
   return _M_narrow[static_cast<unsigned char>(__c)];
 const char __t = do_narrow(__c, __dfault);
 if (__t != __dfault)
   _M_narrow[static_cast<unsigned char>(__c)] = __t;
 return __t;
      }
# 955 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
      char __dfault, char *__to) const
      {
 if (__builtin_expect(_M_narrow_ok == 1, true))
   {
     __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }





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


      static const mask*
      classic_table() throw();
    protected:







      virtual
      ~ctype();
# 1004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1021 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1074 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1097 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
      {
 __builtin_memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }
# 1123 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char) const
      { return __c; }
# 1149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char, char* __dest) const
      {
 __builtin_memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }

    private:
      void _M_narrow_init() const;
      void _M_widen_init() const;
    };
# 1174 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
  template<>
    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    {
    public:


      typedef wchar_t char_type;
      typedef wctype_t __wmask_type;

    protected:
      __c_locale _M_c_locale_ctype;


      bool _M_narrow_ok;
      char _M_narrow[128];
      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


      mask _M_bit[16];
      __wmask_type _M_wmask[16];

    public:


      static locale::id id;
# 1207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1218 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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();
# 1242 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1279 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1297 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1314 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1347 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1364 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1384 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const;
# 1406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
# 1429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const;
# 1455 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef typename ctype<_CharT>::mask mask;

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

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


  template<>
    class ctype_byname<char> : public ctype<char>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname();
    };


  template<>
    class ctype_byname<wchar_t> : public ctype<wchar_t>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname();
    };


}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[static_cast<unsigned char>(__c)] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
      ++__low;
    return __low;
  }

}
# 1511 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3

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


  class __num_base
  {
  public:


    enum
      {
        _S_ominus,
        _S_oplus,
        _S_ox,
        _S_oX,
        _S_odigits,
        _S_odigits_end = _S_odigits + 16,
        _S_oudigits = _S_odigits_end,
        _S_oudigits_end = _S_oudigits + 16,
        _S_oe = _S_odigits + 14,
        _S_oE = _S_oudigits + 14,
 _S_oend = _S_oudigits_end
      };






    static const char* _S_atoms_out;



    static const char* _S_atoms_in;

    enum
    {
      _S_iminus,
      _S_iplus,
      _S_ix,
      _S_iX,
      _S_izero,
      _S_ie = _S_izero + 14,
      _S_iE = _S_izero + 20,
      _S_iend = 26
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod);
  };

  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;
 }
    }
# 1635 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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(); }
# 1672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(__cloc); }
# 1700 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1770 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1787 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1812 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1825 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_numpunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~numpunct_byname() { }
    };


# 1907 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 1928 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1954 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 1990 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2049 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2091 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    protected:

      virtual ~num_get() { }

      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
         string&) const;

      template<typename _ValueT>
        iter_type
        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT&) const;

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
        _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
        {
   int __ret = -1;
   if (__len <= 10)
     {
       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
  __ret = __c - _CharT2('0');
     }
   else
     {
       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
  __ret = __c - _CharT2('0');
       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
  __ret = 10 + (__c - _CharT2('a'));
       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
  __ret = 10 + (__c - _CharT2('A'));
     }
   return __ret;
 }

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
          int>::__type
        _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
        {
   int __ret = -1;
   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
   if (__q)
     {
       __ret = __q - __zero;
       if (__ret > 15)
  __ret -= 6;
     }
   return __ret;
 }
# 2162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned short& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned int& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __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;
# 2227 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2244 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 2265 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2283 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2325 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 2413 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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() { };
# 2461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 __s, ios_base& __io, char_type __fill, long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


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






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, 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;









  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }


  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }


  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }


  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }


  template<typename _CharT>
    inline bool
    islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }


  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }


  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }


  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }


  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }


  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }


  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }


  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }


  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
#define _LOCALE_FACETS_TCC 1

       
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3

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



  template<typename _Facet>
    struct __use_cache
    {
      const _Facet*
      operator() (const locale& __loc) const;
    };


  template<typename _CharT>
    struct __use_cache<__numpunct_cache<_CharT> >
    {
      const __numpunct_cache<_CharT>*
      operator() (const locale& __loc) const
      {
 const size_t __i = numpunct<_CharT>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __numpunct_cache<_CharT>* __tmp = __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>
    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>(_M_grouping[0]) > 0
    && (_M_grouping[0]
        != __gnu_cxx::__numeric_traits<char>::__max));

      _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);
    }
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
  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* __lit_zero = __lit + __num_base::_S_izero;

      if (!__lc->_M_allocated)

 while (!__testeof)
   {
     const int __digit = _M_find(__lit_zero, 10, __c);
     if (__digit != -1)
       {
  __xtrc += '0' + __digit;
  __found_mantissa = true;
       }
     else if (__c == __lc->_M_decimal_point
       && !__found_dec && !__found_sci)
       {
  __xtrc += '.';
  __found_dec = true;
       }
     else if ((__c == __lit[__num_base::_S_ie]
        || __c == __lit[__num_base::_S_iE])
       && !__found_sci && __found_mantissa)
       {

  __xtrc += 'e';
  __found_sci = true;


  if (++__beg != __end)
    {
      __c = *__beg;
      const bool __plus = __c == __lit[__num_base::_S_iplus];
      if (__plus || __c == __lit[__num_base::_S_iminus])
        __xtrc += __plus ? '+' : '-';
      else
        continue;
    }
  else
    {
      __testeof = true;
      break;
    }
       }
     else
       break;

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }
      else
 while (!__testeof)
   {


     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       {
  if (!__found_dec && !__found_sci)
    {


      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {


   __xtrc.clear();
   break;
        }
    }
  else
    break;
       }
     else if (__c == __lc->_M_decimal_point)
       {
  if (!__found_dec && !__found_sci)
    {



      if (__found_grouping.size())
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += '.';
      __found_dec = true;
    }
  else
    break;
       }
     else
       {
  const char_type* __q =
    __traits_type::find(__lit_zero, 10, __c);
  if (__q)
    {
      __xtrc += '0' + (__q - __lit_zero);
      __found_mantissa = true;
      ++__sep_pos;
    }
  else if ((__c == __lit[__num_base::_S_ie]
     || __c == __lit[__num_base::_S_iE])
    && !__found_sci && __found_mantissa)
    {

      if (__found_grouping.size() && !__found_dec)
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += 'e';
      __found_sci = true;


      if (++__beg != __end)
        {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping
     && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
        __xtrc += __plus ? '+' : '-';
   else
     continue;
        }
      else
        {
   __testeof = true;
   break;
        }
    }
  else
    break;
       }

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }



      if (__found_grouping.size())
        {

   if (!__found_dec && !__found_sci)
     __found_grouping += static_cast<char>(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,
          __lc->_M_grouping_size,
          __found_grouping))
     __err = ios_base::failbit;
        }

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    template<typename _ValueT>
      _InIter
      num_get<_CharT, _InIter>::
      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, _ValueT& __v) const
      {
        typedef char_traits<_CharT> __traits_type;
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_in;
 char_type __c = char_type();


 const ios_base::fmtflags __basefield = __io.flags()
                                        & ios_base::basefield;
 const bool __oct = __basefield == ios_base::oct;
 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);


 bool __testeof = __beg == __end;


 bool __negative = false;
 if (!__testeof)
   {
     __c = *__beg;
     __negative = __c == __lit[__num_base::_S_iminus];
     if ((__negative || __c == __lit[__num_base::_S_iplus])
  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  && !(__c == __lc->_M_decimal_point))
       {
  if (++__beg != __end)
    __c = *__beg;
  else
    __testeof = true;
       }
   }



 bool __found_zero = false;
 int __sep_pos = 0;
 while (!__testeof)
   {
     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  || __c == __lc->_M_decimal_point)
       break;
     else if (__c == __lit[__num_base::_S_izero]
       && (!__found_zero || __base == 10))
       {
  __found_zero = true;
  ++__sep_pos;
  if (__basefield == 0)
    __base = 8;
  if (__base == 8)
    __sep_pos = 0;
       }
     else if (__found_zero
       && (__c == __lit[__num_base::_S_ix]
    || __c == __lit[__num_base::_S_iX]))
       {
  if (__basefield == 0)
    __base = 16;
  if (__base == 16)
    {
      __found_zero = false;
      __sep_pos = 0;
    }
  else
    break;
       }
     else
       break;

     if (++__beg != __end)
       {
  __c = *__beg;
  if (!__found_zero)
    break;
       }
     else
       __testeof = true;
   }



 const size_t __len = (__base == 16 ? __num_base::_S_iend
         - __num_base::_S_izero : __base);


 string __found_grouping;
 if (__lc->_M_use_grouping)
   __found_grouping.reserve(32);
 bool __testfail = false;
 bool __testoverflow = false;
 const __unsigned_type __max =
   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
 const __unsigned_type __smax = __max / __base;
 __unsigned_type __result = 0;
 int __digit = 0;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;

 if (!__lc->_M_allocated)

   while (!__testeof)
     {
       __digit = _M_find(__lit_zero, __len, __c);
       if (__digit == -1)
  break;

       if (__result > __smax)
  __testoverflow = true;
       else
  {
    __result *= __base;
    __testoverflow |= __result > __max - __digit;
    __result += __digit;
    ++__sep_pos;
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 else
   while (!__testeof)
     {


       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  {


    if (__sep_pos)
      {
        __found_grouping += static_cast<char>(__sep_pos);
        __sep_pos = 0;
      }
    else
      {
        __testfail = true;
        break;
      }
  }
       else if (__c == __lc->_M_decimal_point)
  break;
       else
  {
    const char_type* __q =
      __traits_type::find(__lit_zero, __len, __c);
    if (!__q)
      break;

    __digit = __q - __lit_zero;
    if (__digit > 15)
      __digit -= 6;
    if (__result > __smax)
      __testoverflow = true;
    else
      {
        __result *= __base;
        __testoverflow |= __result > __max - __digit;
        __result += __digit;
        ++__sep_pos;
      }
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }



 if (__found_grouping.size())
   {

     __found_grouping += static_cast<char>(__sep_pos);

     if (!std::__verify_grouping(__lc->_M_grouping,
     __lc->_M_grouping_size,
     __found_grouping))
       __err = ios_base::failbit;
   }



 if ((!__sep_pos && !__found_zero && !__found_grouping.size())
     || __testfail)
   {
     __v = 0;
     __err = ios_base::failbit;
   }
 else if (__testoverflow)
   {
     if (__negative
  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
     else
       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
     __err = ios_base::failbit;
   }
 else
   __v = __negative ? -__result : __result;

 if (__testeof)
   __err |= ios_base::eofbit;
 return __beg;
      }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {
      if (!(__io.flags() & ios_base::boolalpha))
        {



   long __l = -1;
          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
   if (__l == 0 || __l == 1)
     __v = bool(__l);
   else
     {


       __v = true;
       __err = ios_base::failbit;
       if (__beg == __end)
  __err |= ios_base::eofbit;
     }
        }
      else
        {

   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   bool __testf = true;
   bool __testt = true;
   bool __donef = __lc->_M_falsename_size == 0;
   bool __donet = __lc->_M_truename_size == 0;
   bool __testeof = false;
   size_t __n = 0;
   while (!__donef || !__donet)
     {
       if (__beg == __end)
  {
    __testeof = true;
    break;
  }

       const char_type __c = *__beg;

       if (!__donef)
  __testf = __c == __lc->_M_falsename[__n];

       if (!__testf && __donet)
  break;

       if (!__donet)
  __testt = __c == __lc->_M_truename[__n];

       if (!__testt && __donef)
  break;

       if (!__testt && !__testf)
  break;

       ++__n;
       ++__beg;

       __donef = !__testf || __n >= __lc->_M_falsename_size;
       __donet = !__testt || __n >= __lc->_M_truename_size;
     }
   if (__testf && __n == __lc->_M_falsename_size && __n)
     {
       __v = false;
       if (__testt && __n == __lc->_M_truename_size)
  __err = ios_base::failbit;
       else
  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else if (__testt && __n == __lc->_M_truename_size && __n)
     {
       __v = true;
       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else
     {


       __v = false;
       __err = ios_base::failbit;
       if (__testeof)
  __err |= ios_base::eofbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, float& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }
# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      const fmtflags __fmt = __io.flags();
      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      _UIntPtrType __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      __v = reinterpret_cast<void*>(__ul);
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
        __cs, __w, __len);
      __len = static_cast<int>(__w);
    }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __dec)
    {
      _CharT* __buf = __bufend;
      if (__builtin_expect(__dec, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if ((__flags & ios_base::basefield) == ios_base::oct)
 {

   do
     {
       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *--__buf = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
 }
      return __bufend - __buf;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
    {
      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
     __grouping_size, __cs, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;
 const ios_base::fmtflags __flags = __io.flags();


 const int __ilen = 5 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 const bool __dec = (__basefield != ios_base::oct
       && __basefield != ios_base::hex);
 const __unsigned_type __u = ((__v > 0 || !__dec)
         ? __unsigned_type(__v)
         : -__unsigned_type(__v));
  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * (__len + 1)
          * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
     __cs = __cs2 + 2;
   }


 if (__builtin_expect(__dec, true))
   {

     if (__v >= 0)
       {
  if (bool(__flags & ios_base::showpos)
      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (bool(__flags & ios_base::showbase) && __v)
   {
     if (__basefield == ios_base::oct)
       *--__cs = __lit[__num_base::_S_odigits], ++__len;
     else
       {

  const bool __uppercase = __flags & ios_base::uppercase;
  *--__cs = __lit[__num_base::_S_ox + __uppercase];

  *--__cs = __lit[__num_base::_S_odigits];
  __len += 2;
       }
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      const int __declen = __p ? __p - __cs : __len;
      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
      __grouping_size,
      __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 951 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
         _ValueT __v) const
      {
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);


 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();

 const int __max_digits =
   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;


 int __len;

 char __fbuf[16];
 __num_base::_S_format_float(__io, __fbuf, __mod);




 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
          __fbuf, __prec, __v);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
       __fbuf, __prec, __v);
   }
# 1012 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __len));
 __ctype.widen(__cs, __cs + __len, __ws);


 _CharT* __wp = 0;
 const char* __p = char_traits<char>::find(__cs, __len, '.');
 if (__p)
   {
     __wp = __ws + (__p - __cs);
     *__wp = __lc->_M_decimal_point;
   }




 if (__lc->_M_use_grouping
     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
          && __cs[1] >= '0' && __cs[2] >= '0')))
   {


     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len * 2));

     streamsize __off = 0;
     if (__cs[0] == '-' || __cs[0] == '+')
       {
  __off = 1;
  __ws2[0] = __ws[0];
  __len -= 1;
       }

     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
      __lc->_M_thousands_sep, __wp, __ws2 + __off,
      __ws + __off, __len);
     __len += __off;

     __ws = __ws2;
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
     __ws = __ws3;
   }
 __io.width(0);



 return std::__write(__s, __ws, __len);
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          const long __l = __v;
          __s = _M_insert_int(__s, __io, __fill, __l);
        }
      else
        {
   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   const _CharT* __name = __v ? __lc->_M_truename
                              : __lc->_M_falsename;
   int __len = __v ? __lc->_M_truename_size
                   : __lc->_M_falsename_size;

   const streamsize __w = __io.width();
   if (__w > static_cast<streamsize>(__len))
     {
       const streamsize __plen = __w - __len;
       _CharT* __ps
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __plen));

       char_traits<_CharT>::assign(__ps, __plen, __fill);
       __io.width(0);

       if ((__flags & ios_base::adjustfield) == ios_base::left)
  {
    __s = std::__write(__s, __name, __len);
    __s = std::__write(__s, __ps, __plen);
  }
       else
  {
    __s = std::__write(__s, __ps, __plen);
    __s = std::__write(__s, __name, __len);
  }
       return __s;
     }
   __io.width(0);
   __s = std::__write(__s, __name, __len);
 }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1137 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
    long double __v) const
    { return _M_insert_float(__s, __io, __fill, 'L', __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      const ios_base::fmtflags __fmt = ~(ios_base::basefield
      | ios_base::uppercase);
      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<_UIntPtrType>(__v));
      __io.flags(__flags);
      return __s;
    }


# 1174 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       streamsize __newlen, streamsize __oldlen)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, __olds, __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   if (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0])
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }
   else if (__ctype.widen('0') == __olds[0]
     && __oldlen > 1
     && (__ctype.widen('x') == __olds[1]
         || __ctype.widen('X') == __olds[1]))
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      size_t __idx = 0;
      size_t __ctr = 0;

      while (__last - __first > __gbeg[__idx]
      && static_cast<signed char>(__gbeg[__idx]) > 0
      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
 {
   __last -= __gbeg[__idx];
   __idx < __gsize - 1 ? ++__idx : ++__ctr;
 }

      while (__first != __last)
 *__s++ = *__first++;

      while (__ctr--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      while (__idx--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      return __s;
    }





  extern template class numpunct<char>;
  extern template class numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class ctype_byname<char>;

  extern template
    const ctype<char>&
    use_facet<ctype<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);


  extern template class numpunct<wchar_t>;
  extern template class numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class ctype_byname<wchar_t>;

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

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);



}
# 2600 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets.h" 2 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 2 3


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

  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:






      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;






      typedef ctype<_CharT> __ctype_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
           __num_put_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
           __num_get_type;



    protected:
      basic_ostream<_CharT, _Traits>* _M_tie;
      mutable char_type _M_fill;
      mutable bool _M_fill_init;
      basic_streambuf<_CharT, _Traits>* _M_streambuf;


      const __ctype_type* _M_ctype;

      const __num_put_type* _M_num_put;

      const __num_get_type* _M_num_get;

    public:







      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      bool
      operator!() const
      { return this->fail(); }
# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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() { }
# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
# 336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 350 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 3
      char_type
      widen(char __c) const
      { return __check_facet(_M_ctype).widen(__c); }

    protected:







      basic_ios()
      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
 _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { }







      void
      init(basic_streambuf<_CharT, _Traits>* __sb);

      void
      _M_cache_locale(const locale& __loc);
    };

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.tcc" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.tcc" 3
#define _BASIC_IOS_TCC 1

       
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.tcc" 3

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

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
   _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != &__rhs)
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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>;



}
# 472 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/basic_ios.h" 2 3
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ios" 2 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 2 3


namespace std __attribute__ ((__visibility__ ("default"))) {
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 107 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&))
      {



 return __pf(*this);
      }

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&))
      {



 __pf(*this);
 return *this;
      }

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&))
      {



 __pf(*this);
 return *this;
      }
# 164 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(bool __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(short __n);

      __ostream_type&
      operator<<(unsigned short __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }

      __ostream_type&
      operator<<(int __n);

      __ostream_type&
      operator<<(unsigned int __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }


      __ostream_type&
      operator<<(long long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long long __n)
      { return _M_insert(__n); }


      __ostream_type&
      operator<<(double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(float __f)
      {


 return _M_insert(static_cast<double>(__f));
      }

      __ostream_type&
      operator<<(long double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }
# 249 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 282 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      put(char_type __c);


      void
      _M_write(const char_type* __s, streamsize __n)
      {
 const streamsize __put = this->rdbuf()->sputn(__s, __n);
 if (__put != __n)
   this->setstate(ios_base::badbit);
      }
# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 323 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      flush();
# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      pos_type
      tellp();
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 357 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

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

      template<typename _ValueT>
        __ostream_type&
        _M_insert(_ValueT __v);
    };
# 376 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

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

    public:
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      explicit
      sentry(basic_ostream<_CharT, _Traits>& __os);
# 405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      ~sentry()
      {

 if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
   {

     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
       _M_os.setstate(ios_base::badbit);
   }
      }
# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    { return __ostream_insert(__out, &__c, 1); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    { return __ostream_insert(__out, &__c, 1); }


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }
# 486 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }


  template<class _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    inline basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }
# 536 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }







  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream.tcc" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream.tcc" 3
#define _OSTREAM_TCC 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/ostream.tcc" 3



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

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_ostream<_CharT, _Traits>&
      basic_ostream<_CharT, _Traits>::
      _M_insert(_ValueT __v)
      {
 sentry __cerb(*this);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
     try
       {
  const __num_put_type& __np = __check_facet(this->_M_num_put);
  if (__np.put(*this, *this, this->fill(), __v).failed())
    __err |= ios_base::badbit;
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(short __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(int __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   try
     { _M_write(__s, __n); }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {



      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
     __err |= ios_base::badbit;
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 {


   const size_t __clen = char_traits<char>::length(__s);
   try
     {
       struct __ptr_guard
       {
  _CharT *__p;
  __ptr_guard (_CharT *__ip): __p(__ip) { }
  ~__ptr_guard() { delete[] __p; }
  _CharT* __get() { return __p; }
       } __pg (new _CharT[__clen]);

       _CharT *__ws = __pg.__get();
       for (size_t __i = 0; __i < __clen; ++__i)
  __ws[__i] = __out.widen(__s[__i]);
       __ostream_insert(__out, __ws, __clen);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }





  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);

  extern template ostream& ostream::_M_insert(long);
  extern template ostream& ostream::_M_insert(unsigned long);
  extern template ostream& ostream::_M_insert(bool);

  extern template ostream& ostream::_M_insert(long long);
  extern template ostream& ostream::_M_insert(unsigned long long);

  extern template ostream& ostream::_M_insert(double);
  extern template ostream& ostream::_M_insert(long double);
  extern template ostream& ostream::_M_insert(const void*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);

  extern template wostream& wostream::_M_insert(long);
  extern template wostream& wostream::_M_insert(unsigned long);
  extern template wostream& wostream::_M_insert(bool);

  extern template wostream& wostream::_M_insert(long long);
  extern template wostream& wostream::_M_insert(unsigned long long);

  extern template wostream& wostream::_M_insert(double);
  extern template wostream& wostream::_M_insert(long double);
  extern template wostream& wostream::_M_insert(const void*);



}
# 566 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ostream" 2 3
# 5 "/home/preben/working/CRTPlanner/Constraint.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 1 3
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 3
#define _GLIBCXX_VECTOR 1

       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_construct.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_construct.h" 3
#define _STL_CONSTRUCT_H 1



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





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


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




  template<typename _Tp>
    inline void
    _Destroy(_Tp* __pointer)
    { __pointer->~_Tp(); }

  template<bool>
    struct _Destroy_aux
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator __first, _ForwardIterator __last)
 {
   for (; __first != __last; ++__first)
     std::_Destroy(&*__first);
 }
    };

  template<>
    struct _Destroy_aux<true>
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator, _ForwardIterator) { }
    };






  template<typename _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
 __destroy(__first, __last);
    }







  template <typename _Tp> class allocator;

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

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

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
#define _STL_UNINITIALIZED_H 1

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

  template<bool>
    struct __uninitialized_copy
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        uninitialized_copy(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result)
        {
   _ForwardIterator __cur = __result;
   try
     {
       for (; __first != __last; ++__first, ++__cur)
  ::new(static_cast<void*>(&*__cur)) typename
      iterator_traits<_ForwardIterator>::value_type(*__first);
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__result, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_copy<true>
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        uninitialized_copy(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result)
        { return std::copy(__first, __last, __result); }
    };
# 105 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;

      return std::__uninitialized_copy<(__is_pod(_ValueType1)
     && __is_pod(_ValueType2))>::
 uninitialized_copy(__first, __last, __result);
    }


  template<bool>
    struct __uninitialized_fill
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        uninitialized_fill(_ForwardIterator __first,
      _ForwardIterator __last, const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct(&*__cur, __x);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        uninitialized_fill(_ForwardIterator __first,
      _ForwardIterator __last, const _Tp& __x)
        { std::fill(__first, __last, __x); }
    };
# 162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_fill<__is_pod(_ValueType)>::
 uninitialized_fill(__first, __last, __x);
    }


  template<bool>
    struct __uninitialized_fill_n
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static void
        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
        const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, ++__cur)
  std::_Construct(&*__cur, __x);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill_n<true>
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static void
        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
        const _Tp& __x)
        { std::fill_n(__first, __n, __x); }
    };
# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline void
    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_fill_n<__is_pod(_ValueType)>::
 uninitialized_fill_n(__first, __n, __x);
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __first != __last; ++__first, ++__cur)
     __alloc.construct(&*__cur, *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur, __alloc);
   throw;
 }
    }

  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, allocator<_Tp>&)
    { return std::uninitialized_copy(__first, __last, __result); }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a((__first),
      (__last),
      __result, __alloc);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __cur != __last; ++__cur)
     __alloc.construct(&*__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>
    inline void
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, allocator<_Tp2>&)
    { std::uninitialized_fill_n(__first, __n, __x); }
# 330 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_copy_move(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }





  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_copy(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
         const _Tp& __x, _InputIterator __first,
         _InputIterator __last, _Allocator& __alloc)
    {
      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
      try
 {
   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
    typename _Allocator>
    inline void
    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
           __first2,
           __alloc);
      try
 {
   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2, __alloc);
   throw;
 }
    }
# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_uninitialized.h" 3
}
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
#define _STL_VECTOR_H 1






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


  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;

      struct _Vector_impl
      : public _Tp_alloc_type
      {
 typename _Tp_alloc_type::pointer _M_start;
 typename _Tp_alloc_type::pointer _M_finish;
 typename _Tp_alloc_type::pointer _M_end_of_storage;

 _Vector_impl()
 : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
 { }

 _Vector_impl(_Tp_alloc_type const& __a)
 : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      _Tp_alloc_type&
      _M_get_Tp_allocator()
      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }

      const _Tp_alloc_type&
      _M_get_Tp_allocator() const
      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Tp_allocator()); }

      _Vector_base()
      : _M_impl() { }

      _Vector_base(const allocator_type& __a)
      : _M_impl(__a) { }

      _Vector_base(size_t __n, 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;
      }
# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      ~_Vector_base()
      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
        - this->_M_impl._M_start); }

    public:
      _Vector_impl _M_impl;

      typename _Tp_alloc_type::pointer
      _M_allocate(size_t __n)
      { return __n != 0 ? _M_impl.allocate(__n) : 0; }

      void
      _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n)
      {
 if (__p)
   _M_impl.deallocate(__p, __n);
      }
    };
# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_type::pointer pointer;
      typedef typename _Tp_alloc_type::const_pointer const_pointer;
      typedef typename _Tp_alloc_type::reference reference;
      typedef typename _Tp_alloc_type::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;

    public:





      vector()
      : _Base() { }





      explicit
      vector(const allocator_type& __a)
      : _Base(__a) { }
# 226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      explicit
      vector(size_type __n, const value_type& __value = value_type(),
      const allocator_type& __a = allocator_type())
      : _Base(__n, __a)
      { _M_fill_initialize(__n, __value); }
# 241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(), __x._M_get_Tp_allocator())
      { this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }
# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()); }
# 324 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 389 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
 }
# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      using _Base::get_allocator;







      iterator
      begin()
      { return iterator(this->_M_impl._M_start); }






      const_iterator
      begin() const
      { return const_iterator(this->_M_impl._M_start); }






      iterator
      end()
      { return iterator(this->_M_impl._M_finish); }






      const_iterator
      end() const
      { return const_iterator(this->_M_impl._M_finish); }






      reverse_iterator
      rbegin()
      { return reverse_iterator(end()); }






      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(end()); }






      reverse_iterator
      rend()
      { return reverse_iterator(begin()); }






      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(begin()); }
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      size_type
      size() const
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }


      size_type
      max_size() const
      { return _M_get_Tp_allocator().max_size(); }
# 551 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      void
      resize(size_type __new_size, value_type __x = value_type())
      {
 if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
 else
   insert(end(), __new_size - size(), __x);
      }





      size_type
      capacity() const
      { return size_type(this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start); }





      bool
      empty() const
      { return begin() == end(); }
# 594 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 609 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      reference
      operator[](size_type __n)
      { return *(this->_M_impl._M_start + __n); }
# 624 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      const_reference
      operator[](size_type __n) const
      { return *(this->_M_impl._M_start + __n); }

    protected:

      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("vector::_M_range_check"));
      }

    public:
# 649 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 667 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 732 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
      }
# 763 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      void
      pop_back()
      {
 --this->_M_impl._M_finish;
 this->_M_impl.destroy(this->_M_impl._M_finish);
      }
# 799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 849 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      { _M_fill_insert(__position, __n, __x); }
# 867 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
 }
# 892 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 913 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 925 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);



 std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
          __x._M_get_Tp_allocator());
      }







      void
      clear()
      { _M_erase_at_end(this->_M_impl._M_start); }

    protected:




      template<typename _ForwardIterator>
        pointer
        _M_allocate_and_copy(size_type __n,
        _ForwardIterator __first, _ForwardIterator __last)
        {
   pointer __result = this->_M_allocate(__n);
   try
     {
       std::__uninitialized_copy_a(__first, __last, __result,
       _M_get_Tp_allocator());
       return __result;
     }
   catch(...)
     {
       _M_deallocate(__result, __n);
       throw;
     }
 }
# 984 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
        {
   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
   this->_M_impl._M_end_of_storage =
     this->_M_impl._M_start + static_cast<size_type>(__n);
   _M_fill_initialize(static_cast<size_type>(__n), __value);
 }


      template<typename _InputIterator>
        void
        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
          __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_range_initialize(__first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_range_initialize(_InputIterator __first,
       _InputIterator __last, std::input_iterator_tag)
        {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }


      template<typename _ForwardIterator>
        void
        _M_range_initialize(_ForwardIterator __first,
       _ForwardIterator __last, std::forward_iterator_tag)
        {
   const size_type __n = std::distance(__first, __last);
   this->_M_impl._M_start = this->_M_allocate(__n);
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
   this->_M_impl._M_finish =
     std::__uninitialized_copy_a(__first, __last,
     this->_M_impl._M_start,
     _M_get_Tp_allocator());
 }



      void
      _M_fill_initialize(size_type __n, const value_type& __value)
      {
 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
          _M_get_Tp_allocator());
 this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
      }
# 1048 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
        { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
        void
        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_assign_aux(__first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      void
      _M_fill_assign(size_type __n, const value_type& __val);
# 1088 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
      template<typename _Integer>
        void
        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
        { _M_fill_insert(__pos, __n, __val); }


      template<typename _InputIterator>
        void
        _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_range_insert(__pos, __first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);



      void
      _M_insert_aux(iterator __position, const value_type& __x);







      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + std::max(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }





      void
      _M_erase_at_end(pointer __pos)
      {
 std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
 this->_M_impl._M_finish = __pos;
      }
    };
# 1166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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())); }
# 1183 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 1231 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_vector.h" 3
}
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
#define _STL_BVECTOR_H 1



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

  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  struct _Bit_reference
  {
    _Bit_type * _M_p;
    _Bit_type _M_mask;

    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

    _Bit_reference() : _M_p(0), _M_mask(0) { }

    operator bool() const
    { return !!(*_M_p & _M_mask); }

    _Bit_reference&
    operator=(bool __x)
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }

    _Bit_reference&
    operator=(const _Bit_reference& __x)
    { return *this = bool(__x); }

    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    void
    flip()
    { *_M_p ^= _M_mask; }
  };

  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    void
    _M_bump_up()
    {
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    void
    _M_bump_down()
    {
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    void
    _M_incr(ptrdiff_t __i)
    {
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   __n += int(_S_word_bit);
   --_M_p;
 }
      _M_offset = static_cast<unsigned int>(__n);
    }

    bool
    operator==(const _Bit_iterator_base& __i) const
    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }

    bool
    operator<(const _Bit_iterator_base& __i) const
    {
      return _M_p < __i._M_p
      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
    }

    bool
    operator!=(const _Bit_iterator_base& __i) const
    { return !(*this == __i); }

    bool
    operator>(const _Bit_iterator_base& __i) const
    { return __i < *this; }

    bool
    operator<=(const _Bit_iterator_base& __i) const
    { return !(__i < *this); }

    bool
    operator>=(const _Bit_iterator_base& __i) const
    { return !(*this < __i); }
  };

  inline ptrdiff_t
  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
  {
    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
     + __x._M_offset - __y._M_offset);
  }

  struct _Bit_iterator : public _Bit_iterator_base
  {
    typedef _Bit_reference reference;
    typedef _Bit_reference* pointer;
    typedef _Bit_iterator iterator;

    _Bit_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    reference
    operator*() const
    { return reference(_M_p, 1UL << _M_offset); }

    iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    iterator
    operator++(int)
    {
      iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    iterator
    operator--(int)
    {
      iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    iterator
    operator+(difference_type __i) const
    {
      iterator __tmp = *this;
      return __tmp += __i;
    }

    iterator
    operator-(difference_type __i) const
    {
      iterator __tmp = *this;
      return __tmp -= __i;
    }

    reference
    operator[](difference_type __i) const
    { return *(*this + __i); }
  };

  inline _Bit_iterator
  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
  { return __x + __n; }

  struct _Bit_const_iterator : public _Bit_iterator_base
  {
    typedef bool reference;
    typedef bool const_reference;
    typedef const bool* pointer;
    typedef _Bit_const_iterator const_iterator;

    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }

    const_reference
    operator*() const
    { return _Bit_reference(_M_p, 1UL << _M_offset); }

    const_iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    const_iterator
    operator++(int)
    {
      const_iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    const_iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    const_iterator
    operator--(int)
    {
      const_iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    const_iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    const_iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    const_iterator
    operator+(difference_type __i) const
    {
      const_iterator __tmp = *this;
      return __tmp += __i;
    }

    const_iterator
    operator-(difference_type __i) const
    {
      const_iterator __tmp = *this;
      return __tmp -= __i;
    }

    const_reference
    operator[](difference_type __i) const
    { return *(*this + __i); }
  };

  inline _Bit_const_iterator
  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
  { return __x + __n; }

  inline void
  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
  {
    for (; __first != __last; ++__first)
      *__first = __x;
  }

  inline void
  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
  {
    if (__first._M_p != __last._M_p)
      {
 std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
 __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
 __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
      }
    else
      __fill_bvector(__first, __last, __x);
  }

  template<typename _Alloc>
    struct _Bvector_base
    {
      typedef typename _Alloc::template rebind<_Bit_type>::other
        _Bit_alloc_type;

      struct _Bvector_impl
      : public _Bit_alloc_type
      {
 _Bit_iterator _M_start;
 _Bit_iterator _M_finish;
 _Bit_type* _M_end_of_storage;

 _Bvector_impl()
 : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
 { }

 _Bvector_impl(const _Bit_alloc_type& __a)
 : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      _Bit_alloc_type&
      _M_get_Bit_allocator()
      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }

      const _Bit_alloc_type&
      _M_get_Bit_allocator() const
      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Bit_allocator()); }

      _Bvector_base()
      : _M_impl() { }

      _Bvector_base(const allocator_type& __a)
      : _M_impl(__a) { }
# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      _Bit_type*
      _M_allocate(size_t __n)
      { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
    / int(_S_word_bit)); }

      void
      _M_deallocate()
      {
 if (_M_impl._M_start._M_p)
   _M_impl.deallocate(_M_impl._M_start._M_p,
        _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
      }
    };

}




namespace std __attribute__ ((__visibility__ ("default"))) {
# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
template<typename _Alloc>
  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
  {
    typedef _Bvector_base<_Alloc> _Base;

  public:
    typedef bool value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef _Bit_reference reference;
    typedef bool const_reference;
    typedef _Bit_reference* pointer;
    typedef const bool* const_pointer;
    typedef _Bit_iterator iterator;
    typedef _Bit_const_iterator const_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef _Alloc allocator_type;

    allocator_type get_allocator() const
    { return _Base::get_allocator(); }

  protected:
    using _Base::_M_allocate;
    using _Base::_M_deallocate;
    using _Base::_M_get_Bit_allocator;

  public:
    vector()
    : _Base() { }

    explicit
    vector(const allocator_type& __a)
    : _Base(__a) { }

    explicit
    vector(size_type __n, const bool& __value = bool(),
    const allocator_type& __a = allocator_type())
    : _Base(__a)
    {
      _M_initialize(__n);
      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
  __value ? ~0 : 0);
    }

    vector(const vector& __x)
    : _Base(__x._M_get_Bit_allocator())
    {
      _M_initialize(__x.size());
      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
    }
# 538 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
    template<typename _InputIterator>
      vector(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_initialize_dispatch(__first, __last, _Integral());
      }

    ~vector() { }

    vector&
    operator=(const vector& __x)
    {
      if (&__x == this)
 return *this;
      if (__x.size() > capacity())
 {
   this->_M_deallocate();
   _M_initialize(__x.size());
 }
      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
      begin());
      return *this;
    }
# 586 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
    void
    assign(size_type __n, const bool& __x)
    { _M_fill_assign(__n, __x); }

    template<typename _InputIterator>
      void
      assign(_InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_assign_dispatch(__first, __last, _Integral());
      }







    iterator
    begin()
    { return this->_M_impl._M_start; }

    const_iterator
    begin() const
    { return this->_M_impl._M_start; }

    iterator
    end()
    { return this->_M_impl._M_finish; }

    const_iterator
    end() const
    { return this->_M_impl._M_finish; }

    reverse_iterator
    rbegin()
    { return reverse_iterator(end()); }

    const_reverse_iterator
    rbegin() const
    { return const_reverse_iterator(end()); }

    reverse_iterator
    rend()
    { return reverse_iterator(begin()); }

    const_reverse_iterator
    rend() const
    { return const_reverse_iterator(begin()); }
# 654 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_bvector.h" 3
    size_type
    size() const
    { return size_type(end() - begin()); }

    size_type
    max_size() const
    {
      const size_type __isize =
 __gnu_cxx::__numeric_traits<difference_type>::__max
 - int(_S_word_bit) + 1;
      const size_type __asize = _M_get_Bit_allocator().max_size();
      return (__asize <= __isize / int(_S_word_bit)
       ? __asize * int(_S_word_bit) : __isize);
    }

    size_type
    capacity() const
    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
         - begin()); }

    bool
    empty() const
    { return begin() == end(); }

    reference
    operator[](size_type __n)
    {
      return *iterator(this->_M_impl._M_start._M_p
         + __n / int(_S_word_bit), __n % int(_S_word_bit));
    }

    const_reference
    operator[](size_type __n) const
    {
      return *const_iterator(this->_M_impl._M_start._M_p
        + __n / int(_S_word_bit), __n % int(_S_word_bit));
    }

  protected:
    void
    _M_range_check(size_type __n) const
    {
      if (__n >= this->size())
        __throw_out_of_range(("vector<bool>::_M_range_check"));
    }

  public:
    reference
    at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }

    const_reference
    at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }

    void
    reserve(size_type __n);

    reference
    front()
    { return *begin(); }

    const_reference
    front() const
    { return *begin(); }

    reference
    back()
    { return *(end() - 1); }

    const_reference
    back() const
    { return *(end() - 1); }






    void
    data() { }

    void
    push_back(bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
        *this->_M_impl._M_finish++ = __x;
      else
        _M_insert_aux(end(), __x);
    }

    void



    swap(vector& __x)

    {
      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
      std::swap(this->_M_impl._M_end_of_storage,
  __x._M_impl._M_end_of_storage);



      std::__alloc_swap<typename _Base::_Bit_alloc_type>::
 _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
    }


    static void
    swap(reference __x, reference __y)
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    iterator
    insert(iterator __position, const bool& __x = bool())
    {
      const difference_type __n = __position - begin();
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
   && __position == end())
        *this->_M_impl._M_finish++ = __x;
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }

    template<typename _InputIterator>
      void
      insert(iterator __position,
      _InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_insert_dispatch(__position, __first, __last, _Integral());
      }

    void
    insert(iterator __position, size_type __n, const bool& __x)
    { _M_fill_insert(__position, __n, __x); }






    void
    pop_back()
    { --this->_M_impl._M_finish; }

    iterator
    erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      return __position;
    }

    iterator
    erase(iterator __first, iterator __last)
    {
      _M_erase_at_end(std::copy(__last, end(), __first));
      return __first;
    }

    void
    resize(size_type __new_size, bool __x = bool())
    {
      if (__new_size < size())
        _M_erase_at_end(begin() + difference_type(__new_size));
      else
        insert(end(), __new_size - size(), __x);
    }

    void
    flip()
    {
      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
    __p != this->_M_impl._M_end_of_storage; ++__p)
        *__p = ~*__p;
    }

    void
    clear()
    { _M_erase_at_end(begin()); }


  protected:

    iterator
    _M_copy_aligned(const_iterator __first, const_iterator __last,
      iterator __result)
    {
      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
      return std::copy(const_iterator(__last._M_p, 0), __last,
         iterator(__q, 0));
    }

    void
    _M_initialize(size_type __n)
    {
      _Bit_type* __q = this->_M_allocate(__n);
      this->_M_impl._M_end_of_storage = (__q
      + ((__n + int(_S_word_bit) - 1)
         / int(_S_word_bit)));
      this->_M_impl._M_start = iterator(__q, 0);
      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
    }





    template<typename _Integer>
      void
      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
      {
 _M_initialize(static_cast<size_type>(__n));
 std::fill(this->_M_impl._M_start._M_p,
    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
      }

    template<typename _InputIterator>
      void
      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
        __false_type)
      { _M_initialize_range(__first, __last,
       std::__iterator_category(__first)); }

    template<typename _InputIterator>
      void
      _M_initialize_range(_InputIterator __first, _InputIterator __last,
     std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   push_back(*__first);
      }

    template<typename _ForwardIterator>
      void
      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
     std::forward_iterator_tag)
      {
 const size_type __n = std::distance(__first, __last);
 _M_initialize(__n);
 std::copy(__first, __last, this->_M_impl._M_start);
      }



    template<typename _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign(__n, __val); }

    template<class _InputIterator>
      void
      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }

    void
    _M_fill_assign(size_t __n, bool __x)
    {
      if (__n > size())
 {
   std::fill(this->_M_impl._M_start._M_p,
      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
   insert(end(), __n - size(), __x);
 }
      else
 {
   _M_erase_at_end(begin() + __n);
   std::fill(this->_M_impl._M_start._M_p,
      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
 }
    }

    template<typename _InputIterator>
      void
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 iterator __cur = begin();
 for (; __first != __last && __cur != end(); ++__cur, ++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   insert(end(), __first, __last);
      }

    template<typename _ForwardIterator>
      void
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);
 if (__len < size())
   _M_erase_at_end(std::copy(__first, __last, begin()));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, begin());
     insert(end(), __mid, __last);
   }
      }





    template<typename _Integer>
      void
      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
    __true_type)
      { _M_fill_insert(__pos, __n, __x); }

    template<typename _InputIterator>
      void
      _M_insert_dispatch(iterator __pos,
    _InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_insert_range(__pos, __first, __last,
   std::__iterator_category(__first)); }

    void
    _M_fill_insert(iterator __position, size_type __n, bool __x);

    template<typename _InputIterator>
      void
      _M_insert_range(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   {
     __pos = insert(__pos, *__first);
     ++__pos;
   }
      }

    template<typename _ForwardIterator>
      void
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag);

    void
    _M_insert_aux(iterator __position, bool __x);

    size_type
    _M_check_len(size_type __n, const char* __s) const
    {
      if (max_size() - size() < __n)
 __throw_length_error((__s));

      const size_type __len = size() + std::max(size(), __n);
      return (__len < size() || __len > max_size()) ? max_size() : __len;
    }

    void
    _M_erase_at_end(iterator __pos)
    { this->_M_impl._M_finish = __pos; }
  };

}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/vector.tcc" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/vector.tcc" 3
#define _VECTOR_TCC 1

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

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp = _M_allocate_and_copy(__n,
   (this->_M_impl._M_start),
   (this->_M_impl._M_finish));
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
   _M_get_Tp_allocator());
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/vector.tcc" 3
  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      const size_type __n = __position - begin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
   && __position == end())
 {
   this->_M_impl.construct(this->_M_impl._M_finish, __x);
   ++this->_M_impl._M_finish;
 }
      else
 {
# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/vector.tcc" 3
     _M_insert_aux(__position, __x);
 }
      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __position)
    {
      if (__position + 1 != end())
 std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      this->_M_impl.destroy(this->_M_impl._M_finish);
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __first, iterator __last)
    {
      if (__last != end())
 std::copy(__last, end(), __first);
      _M_erase_at_end(__first.base() + (end() - __last));
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
       end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
       __x._M_impl._M_finish,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_assign(size_t __n, const value_type& __val)
    {
      if (__n > capacity())
 {
   vector __tmp(__n, __val, _M_get_Tp_allocator());
   __tmp.swap(*this);
 }
      else if (__n > size())
 {
   std::fill(begin(), end(), __val);
   std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
     __n - size(), __val,
     _M_get_Tp_allocator());
   this->_M_impl._M_finish += __n - size();
 }
      else
        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 pointer __cur(this->_M_impl._M_start);
 for (; __first != __last && __cur != this->_M_impl._M_finish;
      ++__cur, ++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   insert(end(), __first, __last);
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);

 if (__len > capacity())
   {
     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
     _M_deallocate(this->_M_impl._M_start,
     this->_M_impl._M_end_of_storage
     - this->_M_impl._M_start);
     this->_M_impl._M_start = __tmp;
     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
   }
 else if (size() >= __len)
   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, this->_M_impl._M_start);
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
   }
      }
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/vector.tcc" 3
  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_insert_aux(iterator __position, const _Tp& __x)

    {
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 {
   this->_M_impl.construct(this->_M_impl._M_finish,
      (*(this->_M_impl._M_finish - 1)));

   ++this->_M_impl._M_finish;

   _Tp __x_copy = __x;

   std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);



   *__position = __x_copy;



 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector::_M_insert_aux");
   const size_type __elems_before = __position - begin();
   pointer __new_start(this->_M_allocate(__len));
   pointer __new_finish(__new_start);
   try
     {




       this->_M_impl.construct(__new_start + __elems_before,



                               __x);

       __new_finish = 0;

       __new_finish =
  std::__uninitialized_move_a(this->_M_impl._M_start,
         __position.base(), __new_start,
         _M_get_Tp_allocator());
       ++__new_finish;

       __new_finish =
  std::__uninitialized_move_a(__position.base(),
         this->_M_impl._M_finish,
         __new_finish,
         _M_get_Tp_allocator());
     }
          catch(...)
     {
       if (!__new_finish)
  this->_M_impl.destroy(__new_start + __elems_before);
       else
  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
       _M_deallocate(__new_start, __len);
       throw;
     }
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
   _M_get_Tp_allocator());
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __new_start;
   this->_M_impl._M_finish = __new_finish;
   this->_M_impl._M_end_of_storage = __new_start + __len;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
 {
   if (size_type(this->_M_impl._M_end_of_storage
   - this->_M_impl._M_finish) >= __n)
     {
       value_type __x_copy = __x;
       const size_type __elems_after = end() - __position;
       pointer __old_finish(this->_M_impl._M_finish);
       if (__elems_after > __n)
  {
    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
           this->_M_impl._M_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n;
    std::copy_backward(__position.base(), __old_finish - __n, __old_finish);

    std::fill(__position.base(), __position.base() + __n,
       __x_copy);
  }
       else
  {
    std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
      __n - __elems_after,
      __x_copy,
      _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n - __elems_after;
    std::__uninitialized_move_a(__position.base(), __old_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __elems_after;
    std::fill(__position.base(), __old_finish, __x_copy);
  }
     }
   else
     {
       const size_type __len =
  _M_check_len(__n, "vector::_M_fill_insert");
       const size_type __elems_before = __position - begin();
       pointer __new_start(this->_M_allocate(__len));
       pointer __new_finish(__new_start);
       try
  {

    std::__uninitialized_fill_n_a(__new_start + __elems_before,
      __n, __x,
      _M_get_Tp_allocator());
    __new_finish = 0;

    __new_finish =
      std::__uninitialized_move_a(this->_M_impl._M_start,
      __position.base(),
      __new_start,
      _M_get_Tp_allocator());
    __new_finish += __n;

    __new_finish =
      std::__uninitialized_move_a(__position.base(),
      this->_M_impl._M_finish,
      __new_finish,
      _M_get_Tp_allocator());
  }
       catch(...)
  {
    if (!__new_finish)
      std::_Destroy(__new_start + __elems_before,
      __new_start + __elems_before + __n,
      _M_get_Tp_allocator());
    else
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
    _M_deallocate(__new_start, __len);
    throw;
  }
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_finish;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 for (; __first != __last; ++__first)
   {
     __pos = insert(__pos, *__first);
     ++__pos;
   }
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     const size_type __n = std::distance(__first, __last);
     if (size_type(this->_M_impl._M_end_of_storage
     - this->_M_impl._M_finish) >= __n)
       {
  const size_type __elems_after = end() - __position;
  pointer __old_finish(this->_M_impl._M_finish);
  if (__elems_after > __n)
    {
      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
      this->_M_impl._M_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n;
      std::copy_backward(__position.base(), __old_finish - __n, __old_finish);

      std::copy(__first, __last, __position);
    }
  else
    {
      _ForwardIterator __mid = __first;
      std::advance(__mid, __elems_after);
      std::__uninitialized_copy_a(__mid, __last,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n - __elems_after;
      std::__uninitialized_move_a(__position.base(),
      __old_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __elems_after;
      std::copy(__first, __mid, __position);
    }
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector::_M_range_insert");
  pointer __new_start(this->_M_allocate(__len));
  pointer __new_finish(__new_start);
  try
    {
      __new_finish =
        std::__uninitialized_move_a(this->_M_impl._M_start,
        __position.base(),
        __new_start,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_copy_a(__first, __last,
        __new_finish,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_move_a(__position.base(),
        this->_M_impl._M_finish,
        __new_finish,
        _M_get_Tp_allocator());
    }
  catch(...)
    {
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
      _M_deallocate(__new_start, __len);
      throw;
    }
  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
         _M_get_Tp_allocator());
  _M_deallocate(this->_M_impl._M_start,
         this->_M_impl._M_end_of_storage
         - this->_M_impl._M_start);
  this->_M_impl._M_start = __new_start;
  this->_M_impl._M_finish = __new_finish;
  this->_M_impl._M_end_of_storage = __new_start + __len;
       }
   }
      }




  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   _Bit_type* __q = this->_M_allocate(__n);
   this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
          iterator(__q, 0));
   this->_M_deallocate();
   this->_M_impl._M_start = iterator(__q, 0);
   this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
          / int(_S_word_bit));
 }
    }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, bool __x)
    {
      if (__n == 0)
 return;
      if (capacity() - size() >= __n)
 {
   std::copy_backward(__position, end(),
        this->_M_impl._M_finish + difference_type(__n));
   std::fill(__position, __position + difference_type(__n), __x);
   this->_M_impl._M_finish += difference_type(__n);
 }
      else
 {
   const size_type __len =
     _M_check_len(__n, "vector<bool>::_M_fill_insert");
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = _M_copy_aligned(begin(), __position,
      iterator(__q, 0));
   std::fill(__i, __i + difference_type(__n), __x);
   this->_M_impl._M_finish = std::copy(__position, end(),
           __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

  template<typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<bool, _Alloc>::
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     size_type __n = std::distance(__first, __last);
     if (capacity() - size() >= __n)
       {
  std::copy_backward(__position, end(),
       this->_M_impl._M_finish
       + difference_type(__n));
  std::copy(__first, __last, __position);
  this->_M_impl._M_finish += difference_type(__n);
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector<bool>::_M_insert_range");
  _Bit_type * __q = this->_M_allocate(__len);
  iterator __i = _M_copy_aligned(begin(), __position,
            iterator(__q, 0));
  __i = std::copy(__first, __last, __i);
  this->_M_impl._M_finish = std::copy(__position, end(), __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = (__q
         + ((__len
             + int(_S_word_bit) - 1)
            / int(_S_word_bit)));
  this->_M_impl._M_start = iterator(__q, 0);
       }
   }
      }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_insert_aux(iterator __position, bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
 {
   std::copy_backward(__position, this->_M_impl._M_finish,
        this->_M_impl._M_finish + 1);
   *__position = __x;
   ++this->_M_impl._M_finish;
 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = _M_copy_aligned(begin(), __position,
      iterator(__q, 0));
   *__i++ = __x;
   this->_M_impl._M_finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

}
# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/vector" 2 3
# 6 "/home/preben/working/CRTPlanner/Constraint.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp"
#define _BOOST_UBLAS_VECTOR_ 

# 1 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp"
#define BOOST_UBLAS_STORAGE_H 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/algorithm" 1 3
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/algorithm" 3
#define _GLIBCXX_ALGORITHM 1

       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/algorithm" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
#define _STL_ALGO_H 1

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 2 3


#define _GLIBCXX_CSTDLIB 1
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 28 "/usr/include/stdlib.h" 3 4
#define __need_size_t 

#define __need_wchar_t 
#define __need_NULL 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {


#define _STDLIB_H 1



# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 26 "/usr/include/bits/waitflags.h" 3 4
#define WNOHANG 1
#define WUNTRACED 2


#define WSTOPPED 2
#define WEXITED 4
#define WCONTINUED 8
#define WNOWAIT 0x01000000

#define __WNOTHREAD 0x20000000

#define __WALL 0x40000000
#define __WCLONE 0x80000000
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 29 "/usr/include/bits/waitstatus.h" 3 4
#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)


#define __WTERMSIG(status) ((status) & 0x7f)


#define __WSTOPSIG(status) __WEXITSTATUS(status)


#define __WIFEXITED(status) (__WTERMSIG(status) == 0)


#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)



#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)




#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)



#define __WCOREDUMP(status) ((status) & __WCOREFLAG)


#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#define __W_CONTINUED 0xffff
#define __WCOREFLAG 0x80






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

#define w_termsig __wait_terminated.__w_termsig
#define w_coredump __wait_terminated.__w_coredump
#define w_retcode __wait_terminated.__w_retcode
#define w_stopsig __wait_stopped.__w_stopsig
#define w_stopval __wait_stopped.__w_stopval
# 44 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
#define __WAIT_INT(status) (*(int *) &(status))
# 64 "/usr/include/stdlib.h" 3 4
#define __WAIT_STATUS void *
#define __WAIT_STATUS_DEFN void *
# 85 "/usr/include/stdlib.h" 3 4
#define WEXITSTATUS(status) __WEXITSTATUS (__WAIT_INT (status))
#define WTERMSIG(status) __WTERMSIG (__WAIT_INT (status))
#define WSTOPSIG(status) __WSTOPSIG (__WAIT_INT (status))
#define WIFEXITED(status) __WIFEXITED (__WAIT_INT (status))
#define WIFSIGNALED(status) __WIFSIGNALED (__WAIT_INT (status))
#define WIFSTOPPED(status) __WIFSTOPPED (__WAIT_INT (status))

#define WIFCONTINUED(status) __WIFCONTINUED (__WAIT_INT (status))





typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;
#define __ldiv_t_defined 1






__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
#define __lldiv_t_defined 1





#define RAND_MAX 2147483647




#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0



#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
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))) ;

# 240 "/usr/include/stdlib.h" 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
# 25 "/usr/include/sys/types.h" 3 4
#define _SYS_TYPES_H 1



extern "C" {





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



typedef __loff_t loff_t;



typedef __ino_t ino_t;



#define __ino_t_defined 


typedef __ino64_t ino64_t;
#define __ino64_t_defined 



typedef __dev_t dev_t;
#define __dev_t_defined 
# 72 "/usr/include/sys/types.h" 3 4
typedef __mode_t mode_t;
#define __mode_t_defined 



typedef __nlink_t nlink_t;
#define __nlink_t_defined 
# 105 "/usr/include/sys/types.h" 3 4
typedef __id_t id_t;
#define __id_t_defined 
# 116 "/usr/include/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#define __daddr_t_defined 




typedef __key_t key_t;
#define __key_t_defined 



#define __need_clock_t 

#define __need_time_t 
#define __need_timer_t 
#define __need_clockid_t 
# 141 "/usr/include/sys/types.h" 3 4
typedef __suseconds_t suseconds_t;
#define __suseconds_t_defined 



#define __need_size_t 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 188 "/usr/include/sys/types.h" 3 4
#define __intN_t(N,MODE) typedef int int ##N ##_t __attribute__ ((__mode__ (MODE)))

#define __u_intN_t(N,MODE) typedef unsigned int u_int ##N ##_t __attribute__ ((__mode__ (MODE)))



#define __int8_t_defined 
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__)));





#define __BIT_TYPES_DEFINED__ 1







# 1 "/usr/include/sys/select.h" 1 3 4
# 23 "/usr/include/sys/select.h" 3 4
#define _SYS_SELECT_H 1







# 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



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 24 "/usr/include/bits/select.h" 2 3 4





#define __FD_ZERO_STOS "stosq"




#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
# 59 "/usr/include/bits/select.h" 3 4
#define __FD_SET(d,set) (__FDS_BITS (set)[__FDELT (d)] |= __FDMASK (d))
#define __FD_CLR(d,set) (__FDS_BITS (set)[__FDELT (d)] &= ~__FDMASK (d))
#define __FD_ISSET(d,set) ((__FDS_BITS (set)[__FDELT (d)] & __FDMASK (d)) != 0)
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 35 "/usr/include/sys/select.h" 2 3 4







#define __need_time_t 
#define __need_timespec 

#define __need_timeval 
# 1 "/usr/include/bits/time.h" 1 3 4
# 62 "/usr/include/bits/time.h" 3 4
#undef __need_timeval

#define _STRUCT_TIMEVAL 1




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;


#undef __NFDBITS
#undef __FDELT
#undef __FDMASK

#define __NFDBITS (8 * (int) sizeof (__fd_mask))
#define __FDELT(d) ((d) / __NFDBITS)
#define __FDMASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))


typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
#define __FDS_BITS(set) ((set)->fds_bits)




  } fd_set;


#define FD_SETSIZE __FD_SETSIZE



typedef __fd_mask fd_mask;


#define NFDBITS __NFDBITS




#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)


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
# 22 "/usr/include/sys/sysmacros.h" 3 4
#define _SYS_SYSMACROS_H 1







__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 ();
# 65 "/usr/include/sys/sysmacros.h" 3 4
#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
# 224 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;
#define __blksize_t_defined 





typedef __blkcnt_t blkcnt_t;
#define __blkcnt_t_defined 


typedef __fsblkcnt_t fsblkcnt_t;
#define __fsblkcnt_t_defined 


typedef __fsfilcnt_t fsfilcnt_t;
#define __fsfilcnt_t_defined 
# 262 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 273 "/usr/include/sys/types.h" 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)));






#define __malloc_and_calloc_defined 


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
# 20 "/usr/include/alloca.h" 3 4
#define _ALLOCA_H 1



#define __need_size_t 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {


#undef alloca


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


#define alloca(size) __builtin_alloca (size)


}
# 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))) ;
# 615 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 625 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 637 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 647 "/usr/include/stdlib.h" 3 4
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))) ;
# 669 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 679 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 689 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 701 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;









extern int system (__const char *__command) ;






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





#define __COMPAR_FN_T 
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)));
# 956 "/usr/include/stdlib.h" 3 4
#undef __need_malloc_and_calloc

}
# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 2 3


#undef abort
#undef abs
#undef atexit
#undef atof
#undef atoi
#undef atol
#undef bsearch
#undef calloc
#undef div
#undef exit
#undef free
#undef getenv
#undef labs
#undef ldiv
#undef malloc
#undef mblen
#undef mbstowcs
#undef mbtowc
#undef qsort
#undef rand
#undef realloc
#undef srand
#undef strtod
#undef strtol
#undef strtoul
#undef system
#undef wcstombs
#undef wctomb

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

  using ::div_t;
  using ::ldiv_t;

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

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

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

  using ::wcstombs;
  using ::wctomb;


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

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

}



#undef _Exit
#undef llabs
#undef lldiv
#undef atoll
#undef strtoll
#undef strtoull
#undef strtof
#undef strtold

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


  using ::lldiv_t;





  using ::_Exit;


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


  using ::llabs;

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

  using ::lldiv;
# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;

}

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


  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;

}
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
#define _GLIBCXX_ALGORITHMFWD_H 1

       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3






namespace std __attribute__ ((__visibility__ ("default"))) {
# 198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter, typename _Tp>
    bool
    binary_search(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _IIter, typename _OIter>
    _OIter
    copy(_IIter, _IIter, _OIter);

  template<typename _BIter1, typename _BIter2>
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);
# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter, typename _Tp>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _FIter, typename _Tp>
    void
    fill(_FIter, _FIter, const _Tp&);
# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _OIter, typename _Size, typename _Tp>
    _OIter
    fill_n(_OIter, _Size, const _Tp&);



  template<typename _FIter1, typename _FIter2>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _IIter1, typename _IIter2>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _BIter>
    void
    inplace_merge(_BIter, _BIter, _BIter);

  template<typename _BIter, typename _Compare>
    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);
# 327 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _FIter1, typename _FIter2>
    void
    iter_swap(_FIter1, _FIter2);

  template<typename _FIter, typename _Tp>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _RAIter>
    void
    make_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    make_heap(_RAIter, _RAIter, _Compare);

  template<typename _Tp>
    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);
# 412 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _BIter>
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    bool
    next_permutation(_BIter, _BIter, _Compare);
# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _IIter, typename _RAIter>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  template<typename _IIter, typename _RAIter, typename _Compare>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _RAIter>
    void
    pop_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    pop_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter>
    bool
    prev_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    bool
    prev_permutation(_BIter, _BIter, _Compare);

  template<typename _RAIter>
    void
    push_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    push_heap(_RAIter, _RAIter, _Compare);



  template<typename _FIter, typename _Tp>
    _FIter
    remove(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Predicate>
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

  template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  template<typename _IIter, typename _OIter, typename _Predicate>
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);



  template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);



  template<typename _BIter>
    void
    reverse(_BIter, _BIter);

  template<typename _BIter, typename _OIter>
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

  template<typename _FIter>
    void
    rotate(_FIter, _FIter, _FIter);

  template<typename _FIter, typename _OIter>
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 527 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _RAIter>
    void
    sort_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    sort_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    _BIter
    stable_partition(_BIter, _BIter, _Predicate);

  template<typename _Tp>
    void
    swap(_Tp&, _Tp&);

  template<typename _Tp, size_t _Nm>
    void
    swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);

  template<typename _FIter1, typename _FIter2>
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);



  template<typename _FIter>
    _FIter
    unique(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);



  template<typename _FIter, typename _Tp>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);

}

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

  template<typename _FIter>
    _FIter
    adjacent_find(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

  template<typename _IIter, typename _Predicate>
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

  template<typename _IIter1, typename _IIter2>
    bool
    equal(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    _IIter
    find(_IIter, _IIter, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _IIter, typename _Predicate>
    _IIter
    find_if(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Funct>
    _Funct
    for_each(_IIter, _IIter, _Funct);

  template<typename _FIter, typename _Generator>
    void
    generate(_FIter, _FIter, _Generator);
# 630 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/algorithmfwd.h" 3
  template<typename _OIter, typename _Size, typename _Generator>
    _OIter
    generate_n(_OIter, _Size, _Generator);

  template<typename _IIter1, typename _IIter2>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _FIter>
    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    _FIter
    max_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _FIter>
    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    _FIter
    min_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _RAIter>
    void
    nth_element(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    _BIter
    partition(_BIter, _BIter, _Predicate);

  template<typename _RAIter>
    void
    random_shuffle(_RAIter, _RAIter);

  template<typename _RAIter, typename _Generator>
    void
    random_shuffle(_RAIter, _RAIter, _Generator&);

  template<typename _FIter, typename _Tp>
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

  template<typename _FIter, typename _Predicate, typename _Tp>
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _FIter, typename _Size, typename _Tp>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

  template<typename _FIter, typename _Size, typename _Tp,
    typename _BinaryPredicate>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
        _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _RAIter>
    void
    sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    sort(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    stable_sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    stable_sort(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _OIter, typename _UnaryOperation>
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _BinaryOperation>
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  template<typename _IIter, typename _OIter>
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);

}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 1 3
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
#define _STL_HEAP_H 1




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






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

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      _Compare __comp)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first[__parent], __first[__child]))
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }



  template<typename _RandomAccessIterator, typename _Distance>
    inline bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    { return std::__is_heap_until(__first, __n) == __n; }

  template<typename _RandomAccessIterator, typename _Compare,
    typename _Distance>
    inline bool
    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
    { return std::__is_heap_until(__first, __n, __comp) == __n; }

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

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




  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __push_heap(_RandomAccessIterator __first,
  _Distance __holeIndex, _Distance __topIndex, _Tp __value)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
 {
   *(__first + __holeIndex) = (*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = (__value);
    }
# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;
      ;

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

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
    typename _Compare>
    void
    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
  _Distance __topIndex, _Tp __value, _Compare __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex
      && __comp(*(__first + __parent), __value))
 {
   *(__first + __holeIndex) = (*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = (__value);
    }
# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;
      ;

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

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = (*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)));

   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex,
         (__value));
    }

  template<typename _RandomAccessIterator>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = (*__result);
      *__result = (*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    (__value));
    }
# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      --__last;
      std::__pop_heap(__first, __last, __last);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (__comp(*(__first + __secondChild),
       *(__first + (__secondChild - 1))))
     __secondChild--;
   *(__first + __holeIndex) = (*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)));

   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex,
         (__value), __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = (*__result);
      *__result = (*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    (__value), __comp);
    }
# 348 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;

      --__last;
      std::__pop_heap(__first, __last, __last, __comp);
    }
# 371 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = (*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, (__value));
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 411 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = (*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, (__value),
        __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last);
 }
    }
# 479 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;

      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_heap.h" 3
}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tempbuf.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tempbuf.h" 3
#define _STL_TEMPBUF_H 1





namespace std __attribute__ ((__visibility__ ("default"))) {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len)
    {
      const ptrdiff_t __max =
 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       std::nothrow));
   if (__tmp != 0)
     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len /= 2;
 }
      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    inline void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p, std::nothrow); }







  template<typename _ForwardIterator, typename _Tp>
    class _Temporary_buffer
    {

     

    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef pointer iterator;
      typedef ptrdiff_t size_type;

    protected:
      size_type _M_original_len;
      size_type _M_len;
      pointer _M_buffer;

    public:

      size_type
      size() const
      { return _M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_buffer; }


      iterator
      end()
      { return _M_buffer + _M_len; }





      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);

      ~_Temporary_buffer()
      {
 std::_Destroy(_M_buffer, _M_buffer + _M_len);
 std::return_temporary_buffer(_M_buffer);
      }

    private:

      _Temporary_buffer(const _Temporary_buffer&);

      void
      operator=(const _Temporary_buffer&);
    };

  template<typename _ForwardIterator, typename _Tp>
    _Temporary_buffer<_ForwardIterator, _Tp>::
    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
    : _M_original_len(std::distance(__first, __last)),
      _M_len(0), _M_buffer(0)
    {
      try
 {
   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
         value_type>(_M_original_len));
   _M_buffer = __p.first;
   _M_len = __p.second;
   if (!__is_pod(_Tp) && _M_len > 0)
     std::uninitialized_fill_n(_M_buffer, _M_len, *__first);
 }
      catch(...)
 {
   std::return_temporary_buffer(_M_buffer);
   _M_buffer = 0;
   _M_len = 0;
   throw;
 }
    }

}
# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 2 3





namespace std __attribute__ ((__visibility__ ("default"))) {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }




  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    __find(_InputIterator __first, _InputIterator __last,
    const _Tp& __val, input_iterator_tag)
    {
      while (__first != __last && !(*__first == __val))
 ++__first;
      return __first;
    }


  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    __find_if(_InputIterator __first, _InputIterator __last,
       _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !bool(__pred(*__first)))
 ++__first;
      return __first;
    }


  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
    const _Tp& __val, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;

   if (*__first == __val)
     return __first;
   ++__first;
 }

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


  template<typename _RandomAccessIterator, typename _Predicate>
    _RandomAccessIterator
    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (__pred(*__first))
     return __first;
   ++__first;

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

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

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

      switch (__last - __first)
 {
 case 3:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 2:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 1:
   if (__pred(*__first))
     return __first;
   ++__first;
 case 0:
 default:
   return __last;
 }
    }
# 338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count, const _Tp& __val,
        std::forward_iterator_tag)
    {
      __first = std::find(__first, __last, __val);
      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && *__i == __val)
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = std::find(++__i, __last, __val);
 }
      return __last;
    }






  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        std::random_access_iterator_tag)
    {

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

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

      if (__tailSize < __pattSize)
        return __last;

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

      while (1)
 {


   while (!(*__lookAhead == __val))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        *__backTrack == __val; --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }
# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
           typename _BinaryPredicate>
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count, const _Tp& __val,
        _BinaryPredicate __binary_pred, std::forward_iterator_tag)
    {
      while (__first != __last && !bool(__binary_pred(*__first, __val)))
        ++__first;

      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = ++__i;
   while (__first != __last
   && !bool(__binary_pred(*__first, __val)))
     ++__first;
 }
      return __last;
    }







  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
    {

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

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

      if (__tailSize < __pattSize)
        return __last;

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

      while (1)
 {


   while (!bool(__binary_pred(*__lookAhead, __val)))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        __binary_pred(*__backTrack, __val); --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2, __last2);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2,
      __last2, __comp);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
             __rlast1,
             _RevIterator2(__last2),
             __rlast2);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }

  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
         _RevIterator2(__last2), __rlast2,
         __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 707 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 886 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 923 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {

     
     

     

      ;

      for (; __first != __last; ++__first)
 if (!bool(__pred(*__first)))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {

     

     

      ;

      __first = std::find(__first, __last, __value);
      if(__first == __last)
        return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for(; __first != __last; ++__first)
        if(!(*__first == __value))
          {
            *__result = (*__first);
            ++__result;
          }
      return __result;
    }
# 1141 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      __first = std::find_if(__first, __last, __pred);
      if(__first == __last)
        return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for(; __first != __last; ++__first)
        if(!bool(__pred(*__first)))
          {
            *__result = (*__first);
            ++__result;
          }
      return __result;
    }
# 1181 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 1221 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
           _BinaryPredicate __binary_pred)
    {

     

     


      ;


      __first = std::adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!bool(__binary_pred(*__dest, *__first)))
   *++__dest = (*__first);
      return ++__dest;
    }






  template<typename _ForwardIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result,
    forward_iterator_tag, output_iterator_tag)
    {

      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!(*__first == *__next))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }






  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    input_iterator_tag, output_iterator_tag)
    {

      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!(__value == *__first))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }






  template<typename _InputIterator, typename _ForwardIterator>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    input_iterator_tag, forward_iterator_tag)
    {

      *__result = *__first;
      while (++__first != __last)
 if (!(*__result == *__first))
   *++__result = *__first;
      return ++__result;
    }







  template<typename _ForwardIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    forward_iterator_tag, output_iterator_tag)
    {

     



      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!bool(__binary_pred(*__first, *__next)))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, output_iterator_tag)
    {

     



      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!bool(__binary_pred(__value, *__first)))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, forward_iterator_tag)
    {

     



      *__result = *__first;
      while (++__first != __last)
 if (!bool(__binary_pred(*__result, *__first)))
   *++__result = *__first;
      return ++__result;
    }






  template<typename _BidirectionalIterator>
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   {
     std::iter_swap(__first, __last);
     ++__first;
   }
    }






  template<typename _RandomAccessIterator>
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
       random_access_iterator_tag)
    {
      if (__first == __last)
 return;
      --__last;
      while (__first < __last)
 {
   std::iter_swap(__first, __last);
   ++__first;
   --__last;
 }
    }
# 1449 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1476 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
   _OutputIterator __result)
    {

     

     

      ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }





  template<typename _EuclideanRingElement>
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }


  template<typename _ForwardIterator>
    void
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
      forward_iterator_tag)
    {
      if (__first == __middle || __last == __middle)
 return;

      _ForwardIterator __first2 = __middle;
      do
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      __first2 = __middle;

      while (__first2 != __last)
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
    }


  template<typename _BidirectionalIterator>
    void
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {

     


      if (__first == __middle || __last == __middle)
 return;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 {
   std::iter_swap(__first, --__last);
   ++__first;
 }

      if (__first == __middle)
 std::__reverse(__middle, __last, bidirectional_iterator_tag());
      else
 std::__reverse(__first, __middle, bidirectional_iterator_tag());
    }


  template<typename _RandomAccessIterator>
    void
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {

     


      if (__first == __middle || __last == __middle)
 return;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      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 = std::__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;
 }
    }
# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
    }
# 1703 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
    _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
                _ForwardIterator __last, _OutputIterator __result)
    {

     
     

      ;
      ;

      return std::copy(__first, __middle,
                       std::copy(__middle, __last, __result));
    }


  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred, forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     std::iter_swap(__first, __next);
     ++__first;
   }

      return __first;
    }


  template<typename _BidirectionalIterator, typename _Predicate>
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
  _Predicate __pred, bidirectional_iterator_tag)
    {
      while (true)
 {
   while (true)
     if (__first == __last)
       return __first;
     else if (__pred(*__first))
       ++__first;
     else
       break;
   --__last;
   while (true)
     if (__first == __last)
       return __first;
     else if (!bool(__pred(*__last)))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }




  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
    _ForwardIterator
    __inplace_stable_partition(_ForwardIterator __first,
          _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;
 }
    }
# 1861 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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(),
       _DistanceType(__buf.size()));
 else
   return
     std::__inplace_stable_partition(__first, __last, __pred,
      _DistanceType(__buf.requested_size()));
 }
    }


  template<typename _RandomAccessIterator>
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last)
    {
      std::make_heap(__first, __middle);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (*__i < *__first)
   std::__pop_heap(__first, __middle, __i);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last, _Compare __comp)
    {
      std::make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(*__i, *__first))
   std::__pop_heap(__first, __middle, __i, __comp);
    }
# 1943 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2009 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 _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);
    }





  enum { _S_threshold = 16 };


  template<typename _RandomAccessIterator>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold));
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
 }
      else
 std::__insertion_sort(__first, __last);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }


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


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


  template<typename _Size>
    inline _Size
    __lg(_Size __n)
    {
      _Size __k;
      for (__k = 0; __n != 0; __n >>= 1)
 ++__k;
      return __k - 1;
    }

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

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

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



  template<typename _RandomAccessIterator, typename _Size>
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last);


       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__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);
    }

  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last, __comp);

       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__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);
    }
# 2418 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2469 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2518 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2569 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 2624 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 2686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 2747 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;


     
     
      ;
      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
      return __i != __last && !(__val < *__i);
    }
# 2780 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;


     
     

      ;

      ;


      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
      return __i != __last && !bool(__comp(__val, *__i));
    }




  template<typename _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);
 }
    }


  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);
    }
# 3128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()));
    }
# 3183 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 _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);
    }

  template<typename _RandomAccessIterator, typename _Distance>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Pointer>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle,
          __buffer, __buffer_size);
   std::__stable_sort_adaptive(__middle, __last,
          __buffer, __buffer_size);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer);
   std::__merge_sort_with_buffer(__middle, __last, __buffer);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size,
                           _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive(__middle, __last, __buffer,
          __buffer_size, __comp);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size,
       __comp);
    }


  template<typename _RandomAccessIterator>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle);
      std::__inplace_stable_sort(__middle, __last);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 3468 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     
     
      ;
      ;

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

      return __first2 == __last2;
    }
# 3517 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

      ;
      ;

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

      return __first2 == __last2;
    }
# 3572 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
     }
 }
    }
# 3629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__i, *__ii))
     {
       _BidirectionalIterator __j = __last;
       while (!bool(__comp(*__i, *--__j)))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3685 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
     }
 }
    }
# 3742 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__ii, *__i))
     {
       _BidirectionalIterator __j = __last;
       while (!bool(__comp(*--__j, *__i)))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 3802 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 3839 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4176 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
}

namespace std __attribute__ ((__visibility__ ("default"))) {
# 4192 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4213 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 4237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 4266 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4305 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4337 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4466 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;


      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 return std::find(__first1, __last1, *__first2);


      _ForwardIterator2 __p;
      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   __first1 = std::find(__first1, __last1, *__first2);
   if (__first1 == __last1)
     return __last1;

   __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (*__current == *__p)
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }
# 4537 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {

     
     
     


      ;
      ;


      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 {
   while (__first1 != __last1
   && !bool(__predicate(*__first1, *__first2)))
     ++__first1;
   return __first1;
 }


      _ForwardIterator2 __p;
      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   while (__first1 != __last1
   && !bool(__predicate(*__first1, *__first2)))
     ++__first1;
   if (__first1 == __last1)
     return __last1;

   __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (__predicate(*__current, *__p))
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }
# 4611 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 4647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
           typename _BinaryPredicate>
    _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__count <= 0)
 return __first;
      if (__count == 1)
 {
   while (__first != __last && !bool(__binary_pred(*__first, __val)))
     ++__first;
   return __first;
 }
      return std::__search_n(__first, __last, __count, __val, __binary_pred,
        std::__iterator_category(__first));
    }
# 4689 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4725 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4758 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4790 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4822 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4850 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 4886 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4925 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result, __binary_pred,
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4957 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)));
    }
# 4985 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 5017 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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));
    }
# 5051 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::__heap_select(__first, __middle, __last);
      std::sort_heap(__first, __middle);
    }
# 5090 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      std::__heap_select(__first, __middle, __last, __comp);
      std::sort_heap(__first, __middle, __comp);
    }
# 5128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2);
    }
# 5167 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2, __comp);
    }
# 5205 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2);
   std::__final_insertion_sort(__first, __last);
 }
    }
# 5241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2, __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }
# 5282 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (*__first2 < *__first1)
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(*__first2, *__first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()));
    }
# 5447 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
    }
# 5493 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (*__first1 < *__first2)
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (*__first2 < *__first1)
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5560 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(*__first1, *__first2))
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (__comp(*__first2, *__first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 5627 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   ++__first1;
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5684 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   ++__first1;
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5742 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5803 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5861 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     
     
      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2, std::copy(__first1,
          __last1, __result));
    }
# 5927 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
 _ValueType2;


     
     
     

     

     

     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(*__first2, *__first1))
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5984 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (*__first < *__result)
   __result = __first;
      return __result;
    }
# 6012 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 6040 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
    }
# 6068 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;

      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(*__result, *__first))
   __result = __first;
      return __result;
    }

}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/algorithm" 2 3
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 2




# 1 "/usr/include/boost-1_41/boost/serialization/array.hpp" 1

#define BOOST_SERIALIZATION_ARRAY_HPP 






# 1 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 1

#define BOOST_SERIALIZATION_NVP_HPP 
# 19 "/usr/include/boost-1_41/boost/serialization/nvp.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/utility" 1 3
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/utility" 3
#define _GLIBCXX_UTILITY 1

       
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/utility" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 1 3
# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 3
#define _STL_RELOPS_H 1

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

  namespace rel_ops
  {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }

  }

}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/utility" 2 3
# 20 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2

# 1 "/usr/include/boost-1_41/boost/config.hpp" 1
# 18 "/usr/include/boost-1_41/boost/config.hpp"
#define BOOST_CONFIG_HPP 



#define BOOST_USER_CONFIG <boost/config/user.hpp>



# 1 "/usr/include/boost-1_41/boost/config/user.hpp" 1
# 27 "/usr/include/boost-1_41/boost/config.hpp" 2




# 1 "/usr/include/boost-1_41/boost/config/select_compiler_config.hpp" 1
# 17 "/usr/include/boost-1_41/boost/config/select_compiler_config.hpp"
#define BOOST_CXX_GCCXML 0
#define BOOST_CXX_COMO 0
#define BOOST_CXX_DMC 0
#define BOOST_CXX_INTEL 0
#define BOOST_CXX_GNUC 0
#define BOOST_CXX_KCC 0
#define BOOST_CXX_SGI 0
#define BOOST_CXX_TRU64 0
#define BOOST_CXX_GHS 0
#define BOOST_CXX_BORLAND 0
#define BOOST_CXX_CW 0
#define BOOST_CXX_SUNPRO 0
#define BOOST_CXX_HPACC 0
#define BOOST_CXX_MPW 0
#define BOOST_CXX_IBMCPP 0
#define BOOST_CXX_MSVC 0
#define BOOST_CXX_PGI 0
# 57 "/usr/include/boost-1_41/boost/config/select_compiler_config.hpp"
#define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
# 32 "/usr/include/boost-1_41/boost/config.hpp" 2



# 1 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp" 1
# 89 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp"
#define BOOST_HAS_LONG_LONG 





#define BOOST_HAS_NRVO 
# 109 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp"
#define BOOST_NO_CONSTEXPR 
#define BOOST_NO_EXTERN_TEMPLATE 
#define BOOST_NO_LAMBDAS 
#define BOOST_NO_NULLPTR 
#define BOOST_NO_RAW_LITERALS 
#define BOOST_NO_TEMPLATE_ALIASES 
#define BOOST_NO_UNICODE_LITERALS 
# 128 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp"
#define BOOST_NO_DECLTYPE 
#define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 
#define BOOST_NO_RVALUE_REFERENCES 
#define BOOST_NO_STATIC_ASSERT 






#define BOOST_NO_VARIADIC_TEMPLATES 






#define BOOST_NO_AUTO_DECLARATIONS 
#define BOOST_NO_AUTO_MULTIDECLARATIONS 
#define BOOST_NO_CHAR16_T 
#define BOOST_NO_CHAR32_T 
#define BOOST_NO_DEFAULTED_FUNCTIONS 
#define BOOST_NO_DELETED_FUNCTIONS 
#define BOOST_NO_INITIALIZER_LISTS 
#define BOOST_NO_SCOPED_ENUMS 
# 164 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp"
#define BOOST_NO_SCOPED_ENUMS 





#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS 
# 179 "/usr/include/boost-1_41/boost/config/compiler/gcc.hpp"
#define BOOST_NO_CONCEPTS 



#define BOOST_COMPILER "GNU C++ version " __VERSION__
# 36 "/usr/include/boost-1_41/boost/config.hpp" 2




# 1 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp" 1
# 17 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 18 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp" 2
# 33 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp"
# 1 "/usr/include/boost-1_41/boost/config/no_tr1/utility.hpp" 1
# 14 "/usr/include/boost-1_41/boost/config/no_tr1/utility.hpp"
#define BOOST_CONFIG_UTILITY 


#define BOOST_TR1_NO_RECURSION 
#define BOOST_CONFIG_NO_UTILITY_RECURSION 





#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_UTILITY_RECURSION
# 34 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp" 2
# 45 "/usr/include/boost-1_41/boost/config/select_stdlib_config.hpp"
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
# 41 "/usr/include/boost-1_41/boost/config.hpp" 2



# 1 "/usr/include/boost-1_41/boost/config/stdlib/libstdcpp3.hpp" 1
# 13 "/usr/include/boost-1_41/boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
# 40 "/usr/include/boost-1_41/boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_HAS_THREADS 
# 67 "/usr/include/boost-1_41/boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
#define BOOST_HAS_SLIST 
#define BOOST_HAS_HASH 
#define BOOST_SLIST_HEADER <ext/slist>




#define BOOST_HASH_SET_HEADER <backward/hash_set>
#define BOOST_HASH_MAP_HEADER <backward/hash_map>
# 95 "/usr/include/boost-1_41/boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_NO_0X_HDR_ARRAY 
#define BOOST_NO_0X_HDR_RANDOM 
#define BOOST_NO_0X_HDR_REGEX 
#define BOOST_NO_0X_HDR_TUPLE 
#define BOOST_NO_0X_HDR_TYPE_TRAITS 
#define BOOST_NO_STD_UNORDERED 
#define BOOST_NO_0X_HDR_UNORDERED_MAP 
#define BOOST_NO_0X_HDR_UNORDERED_SET 





#define BOOST_NO_0X_HDR_CHRONO 
#define BOOST_NO_0X_HDR_CONDITION_VARIABLE 
#define BOOST_NO_0X_HDR_FORWARD_LIST 
#define BOOST_NO_0X_HDR_INITIALIZER_LIST 
#define BOOST_NO_0X_HDR_MUTEX 
#define BOOST_NO_0X_HDR_RATIO 
#define BOOST_NO_0X_HDR_SYSTEM_ERROR 
#define BOOST_NO_0X_HDR_THREAD 




#define BOOST_NO_0X_HDR_CODECVT 
#define BOOST_NO_0X_HDR_CONCEPTS 
#define BOOST_NO_0X_HDR_CONTAINER_CONCEPTS 
#define BOOST_NO_0X_HDR_FUTURE 
#define BOOST_NO_0X_HDR_ITERATOR_CONCEPTS 
#define BOOST_NO_0X_HDR_MEMORY_CONCEPTS 
# 45 "/usr/include/boost-1_41/boost/config.hpp" 2




# 1 "/usr/include/boost-1_41/boost/config/select_platform_config.hpp" 1
# 18 "/usr/include/boost-1_41/boost/config/select_platform_config.hpp"
#define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
# 50 "/usr/include/boost-1_41/boost/config.hpp" 2



# 1 "/usr/include/boost-1_41/boost/config/platform/linux.hpp" 1
# 11 "/usr/include/boost-1_41/boost/config/platform/linux.hpp"
#define BOOST_PLATFORM "linux"


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 2 3
# 15 "/usr/include/boost-1_41/boost/config/platform/linux.hpp" 2
# 25 "/usr/include/boost-1_41/boost/config/platform/linux.hpp"
#define BOOST_HAS_STDINT_H 
# 50 "/usr/include/boost-1_41/boost/config/platform/linux.hpp"
#define BOOST_HAS_GETTIMEOFDAY 



#define BOOST_HAS_NANOSLEEP 
# 69 "/usr/include/boost-1_41/boost/config/platform/linux.hpp"
#define BOOST_HAS_UNISTD_H 
# 1 "/usr/include/boost-1_41/boost/config/posix_features.hpp" 1
# 22 "/usr/include/boost-1_41/boost/config/posix_features.hpp"
#define BOOST_HAS_NL_TYPES_H 




#define BOOST_HAS_STDINT_H 




#define BOOST_HAS_DIRENT_H 




#define BOOST_HAS_SIGACTION 
# 46 "/usr/include/boost-1_41/boost/config/posix_features.hpp"
#define BOOST_HAS_PTHREADS 






#define BOOST_HAS_NANOSLEEP 







#define BOOST_HAS_CLOCK_GETTIME 
# 70 "/usr/include/boost-1_41/boost/config/posix_features.hpp"
#define BOOST_HAS_SCHED_YIELD 
# 79 "/usr/include/boost-1_41/boost/config/posix_features.hpp"
#define BOOST_HAS_GETTIMEOFDAY 

#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 


#define BOOST_HAS_LOG1P 


#define BOOST_HAS_EXPM1 
# 71 "/usr/include/boost-1_41/boost/config/platform/linux.hpp" 2
# 54 "/usr/include/boost-1_41/boost/config.hpp" 2



# 1 "/usr/include/boost-1_41/boost/config/suffix.hpp" 1
# 26 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_CONFIG_SUFFIX_HPP 
# 90 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_NO_MS_INT64_NUMERIC_LIMITS 
# 99 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_MSVC6_MEMBER_TEMPLATES 
# 173 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR 
# 344 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_PREVENT_MACRO_SUBSTITUTION 


#define BOOST_USING_STD_MIN() using std::min



#define BOOST_USING_STD_MAX() using std::max
# 380 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_STATIC_CONSTANT(type,assignment) static const type assignment
# 408 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_USE_FACET(Type,loc) std::use_facet< Type >(loc)
#define BOOST_HAS_FACET(Type,loc) std::has_facet< Type >(loc)
# 423 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_NESTED_TEMPLATE template
# 436 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_UNREACHABLE_RETURN(x) 
# 451 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_DEDUCED_TYPENAME typename





#define BOOST_CTOR_TYPENAME typename
# 468 "/usr/include/boost-1_41/boost/config/suffix.hpp"
namespace boost{

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




}
# 544 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_EXPLICIT_TEMPLATE_TYPE(t) 
#define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 

#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 
# 565 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X
# 576 "/usr/include/boost-1_41/boost/config/suffix.hpp"
#define BOOST_JOIN(X,Y) BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN(X,Y) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2(X,Y) X ##Y
# 58 "/usr/include/boost-1_41/boost/config.hpp" 2
# 22 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2
# 1 "/usr/include/boost-1_41/boost/detail/workaround.hpp" 1





#define WORKAROUND_DWA2002126_HPP 
# 44 "/usr/include/boost-1_41/boost/detail/workaround.hpp"
#define __BORLANDC___WORKAROUND_GUARD 1




#define __CODEGEARC___WORKAROUND_GUARD 1




#define _MSC_VER_WORKAROUND_GUARD 1




#define _MSC_FULL_VER_WORKAROUND_GUARD 1




#define BOOST_MSVC_WORKAROUND_GUARD 1






#define __GNUC___WORKAROUND_GUARD 0




#define __GNUC_MINOR___WORKAROUND_GUARD 0




#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0


#define __IBMCPP___WORKAROUND_GUARD 1




#define __SUNPRO_CC_WORKAROUND_GUARD 1




#define __DECCXX_VER_WORKAROUND_GUARD 1




#define __MWERKS___WORKAROUND_GUARD 1




#define __EDG___WORKAROUND_GUARD 1




#define __EDG_VERSION___WORKAROUND_GUARD 1




#define __HP_aCC_WORKAROUND_GUARD 1




#define __hpxstd98_WORKAROUND_GUARD 1




#define _CRAYC_WORKAROUND_GUARD 1




#define __DMC___WORKAROUND_GUARD 1




#define MPW_CPLUS_WORKAROUND_GUARD 1




#define __COMO___WORKAROUND_GUARD 1




#define __COMO_VERSION___WORKAROUND_GUARD 1




#define __INTEL_COMPILER_WORKAROUND_GUARD 1




#define __ICL_WORKAROUND_GUARD 1




#define _COMPILER_VERSION_WORKAROUND_GUARD 1





#define _RWSTD_VER_WORKAROUND_GUARD 1




#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1




#define __GLIBCPP___WORKAROUND_GUARD 1




#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1




#define __SGI_STL_PORT_WORKAROUND_GUARD 1




#define _STLPORT_VERSION_WORKAROUND_GUARD 1




#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1




#define _CPPLIB_VER_WORKAROUND_GUARD 1





#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1




#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1




#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1




#define BOOST_INTEL_WORKAROUND_GUARD 1




#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0

#define BOOST_WORKAROUND(symbol,test) ((symbol ## _WORKAROUND_GUARD + 0 == 0) && (symbol != 0) && (1 % (( (symbol test) ) + 1)))
# 253 "/usr/include/boost-1_41/boost/detail/workaround.hpp"
#define BOOST_TESTED_AT(value) != ((value)-(value))
# 23 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2





# 1 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp" 1


#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/integral_c_fwd.hpp" 1


#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/integral_c_fwd.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/workaround.hpp" 1


#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/integral_c_fwd.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/adl_barrier.hpp" 1


#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/adl_barrier.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/adl.hpp" 1


#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/config/adl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/msvc.hpp" 1


#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/intel.hpp" 1


#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/gcc.hpp" 1


#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/config/gcc.hpp"
#define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/config/adl.hpp" 2
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/adl_barrier.hpp" 2





#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
#define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) namespace boost { namespace mpl { using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; } }






namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 19 "/usr/include/boost-1_41/boost/mpl/integral_c_fwd.hpp" 2

namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/ctps.hpp" 1


#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/static_constant.hpp" 1


#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp" 2






#define AUX_WRAPPER_PARAMS(N) typename T, T N


#define AUX_WRAPPER_NAME integral_c
#define AUX_WRAPPER_VALUE_TYPE T
#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 1
# 16 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/integral_c_tag.hpp" 1


#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/integral_c_tag.hpp"
namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/static_cast.hpp" 1


#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/static_cast.hpp"
#define BOOST_MPL_AUX_STATIC_CAST(T,expr) static_cast<T>(expr)
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/nttp_decl.hpp" 1


#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/nttp_decl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/nttp.hpp" 1


#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/nttp_decl.hpp" 2
# 31 "/usr/include/boost-1_41/boost/mpl/aux_/nttp_decl.hpp"
#define BOOST_MPL_AUX_NTTP_DECL(T,x) T x
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 2



# 1 "/usr/include/boost-1_41/boost/preprocessor/cat.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/cat.hpp"
#define BOOST_PREPROCESSOR_CAT_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/config/config.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/config/config.hpp"
#define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP 



#define BOOST_PP_CONFIG_STRICT() 0x0001
#define BOOST_PP_CONFIG_IDEAL() 0x0002

#define BOOST_PP_CONFIG_MSVC() 0x0004
#define BOOST_PP_CONFIG_MWCC() 0x0008
#define BOOST_PP_CONFIG_BCC() 0x0010
#define BOOST_PP_CONFIG_EDG() 0x0020
#define BOOST_PP_CONFIG_DMC() 0x0040
# 50 "/usr/include/boost-1_41/boost/preprocessor/config/config.hpp"
#define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())






#define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0
# 66 "/usr/include/boost-1_41/boost/preprocessor/config/config.hpp"
#define BOOST_PP_CONFIG_ERRORS 1
# 18 "/usr/include/boost-1_41/boost/preprocessor/cat.hpp" 2




#define BOOST_PP_CAT(a,b) BOOST_PP_CAT_I(a, b)






#define BOOST_PP_CAT_I(a,b) a ## b
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 2
# 40 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template< typename T, T N >
struct integral_c
{
    static const T value = N;





    typedef integral_c type;

    typedef T value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
    typedef integral_c< T, static_cast<T>((value + 1)) > next;
    typedef integral_c< T, static_cast<T>((value - 1)) > prior;






    operator T() const { return static_cast<T>(this->value); }
};


template< typename T, T N >
T const integral_c< T, N >::value;


}

#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
# 33 "/usr/include/boost-1_41/boost/mpl/integral_c.hpp" 2




namespace mpl_ {

template< bool C >
struct integral_c<bool, C>
{
    static const bool value = C;
    typedef integral_c_tag tag;
    typedef integral_c type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};
}
# 29 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2


# 1 "/usr/include/boost-1_41/boost/serialization/level.hpp" 1

#define BOOST_SERIALIZATION_LEVEL_HPP 
# 22 "/usr/include/boost-1_41/boost/serialization/level.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp"
#define BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp"
#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/is_integral.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_integral.hpp"
#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/int.hpp" 1


#define BOOST_MPL_INT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/int.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/int_fwd.hpp" 1


#define BOOST_MPL_INT_FWD_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/int_fwd.hpp"
namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/usr/include/boost-1_41/boost/mpl/int.hpp" 2

#define AUX_WRAPPER_VALUE_TYPE int
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)



#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)






#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >



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-1_41/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;






    operator int() const { return static_cast<int>(this->value); }
};


template< int N >
int const mpl_::int_< N >::value;


}

#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
# 21 "/usr/include/boost-1_41/boost/mpl/int.hpp" 2
# 11 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/template_arity_fwd.hpp" 1


#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/template_arity_fwd.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 12 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp" 1


#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/preprocessor.hpp" 1


#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED 
# 30 "/usr/include/boost-1_41/boost/mpl/aux_/config/preprocessor.hpp"
#define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp" 2
# 45 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/comma_if.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/comma_if.hpp"
#define BOOST_PREPROCESSOR_COMMA_IF_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma_if.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma_if.hpp"
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/control/if.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/control/if.hpp"
#define BOOST_PREPROCESSOR_CONTROL_IF_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/control/iif.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/control/iif.hpp"
#define BOOST_PREPROCESSOR_CONTROL_IIF_HPP 




#define BOOST_PP_IIF(bit,t,f) BOOST_PP_IIF_I(bit, t, f)






#define BOOST_PP_IIF_I(bit,t,f) BOOST_PP_IIF_ ## bit(t, f)





#define BOOST_PP_IIF_0(t,f) f
#define BOOST_PP_IIF_1(t,f) t
# 19 "/usr/include/boost-1_41/boost/preprocessor/control/if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/logical/bool.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/logical/bool.hpp"
#define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP 






#define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x)





#define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x

#define BOOST_PP_BOOL_0 0
#define BOOST_PP_BOOL_1 1
#define BOOST_PP_BOOL_2 1
#define BOOST_PP_BOOL_3 1
#define BOOST_PP_BOOL_4 1
#define BOOST_PP_BOOL_5 1
#define BOOST_PP_BOOL_6 1
#define BOOST_PP_BOOL_7 1
#define BOOST_PP_BOOL_8 1
#define BOOST_PP_BOOL_9 1
#define BOOST_PP_BOOL_10 1
#define BOOST_PP_BOOL_11 1
#define BOOST_PP_BOOL_12 1
#define BOOST_PP_BOOL_13 1
#define BOOST_PP_BOOL_14 1
#define BOOST_PP_BOOL_15 1
#define BOOST_PP_BOOL_16 1
#define BOOST_PP_BOOL_17 1
#define BOOST_PP_BOOL_18 1
#define BOOST_PP_BOOL_19 1
#define BOOST_PP_BOOL_20 1
#define BOOST_PP_BOOL_21 1
#define BOOST_PP_BOOL_22 1
#define BOOST_PP_BOOL_23 1
#define BOOST_PP_BOOL_24 1
#define BOOST_PP_BOOL_25 1
#define BOOST_PP_BOOL_26 1
#define BOOST_PP_BOOL_27 1
#define BOOST_PP_BOOL_28 1
#define BOOST_PP_BOOL_29 1
#define BOOST_PP_BOOL_30 1
#define BOOST_PP_BOOL_31 1
#define BOOST_PP_BOOL_32 1
#define BOOST_PP_BOOL_33 1
#define BOOST_PP_BOOL_34 1
#define BOOST_PP_BOOL_35 1
#define BOOST_PP_BOOL_36 1
#define BOOST_PP_BOOL_37 1
#define BOOST_PP_BOOL_38 1
#define BOOST_PP_BOOL_39 1
#define BOOST_PP_BOOL_40 1
#define BOOST_PP_BOOL_41 1
#define BOOST_PP_BOOL_42 1
#define BOOST_PP_BOOL_43 1
#define BOOST_PP_BOOL_44 1
#define BOOST_PP_BOOL_45 1
#define BOOST_PP_BOOL_46 1
#define BOOST_PP_BOOL_47 1
#define BOOST_PP_BOOL_48 1
#define BOOST_PP_BOOL_49 1
#define BOOST_PP_BOOL_50 1
#define BOOST_PP_BOOL_51 1
#define BOOST_PP_BOOL_52 1
#define BOOST_PP_BOOL_53 1
#define BOOST_PP_BOOL_54 1
#define BOOST_PP_BOOL_55 1
#define BOOST_PP_BOOL_56 1
#define BOOST_PP_BOOL_57 1
#define BOOST_PP_BOOL_58 1
#define BOOST_PP_BOOL_59 1
#define BOOST_PP_BOOL_60 1
#define BOOST_PP_BOOL_61 1
#define BOOST_PP_BOOL_62 1
#define BOOST_PP_BOOL_63 1
#define BOOST_PP_BOOL_64 1
#define BOOST_PP_BOOL_65 1
#define BOOST_PP_BOOL_66 1
#define BOOST_PP_BOOL_67 1
#define BOOST_PP_BOOL_68 1
#define BOOST_PP_BOOL_69 1
#define BOOST_PP_BOOL_70 1
#define BOOST_PP_BOOL_71 1
#define BOOST_PP_BOOL_72 1
#define BOOST_PP_BOOL_73 1
#define BOOST_PP_BOOL_74 1
#define BOOST_PP_BOOL_75 1
#define BOOST_PP_BOOL_76 1
#define BOOST_PP_BOOL_77 1
#define BOOST_PP_BOOL_78 1
#define BOOST_PP_BOOL_79 1
#define BOOST_PP_BOOL_80 1
#define BOOST_PP_BOOL_81 1
#define BOOST_PP_BOOL_82 1
#define BOOST_PP_BOOL_83 1
#define BOOST_PP_BOOL_84 1
#define BOOST_PP_BOOL_85 1
#define BOOST_PP_BOOL_86 1
#define BOOST_PP_BOOL_87 1
#define BOOST_PP_BOOL_88 1
#define BOOST_PP_BOOL_89 1
#define BOOST_PP_BOOL_90 1
#define BOOST_PP_BOOL_91 1
#define BOOST_PP_BOOL_92 1
#define BOOST_PP_BOOL_93 1
#define BOOST_PP_BOOL_94 1
#define BOOST_PP_BOOL_95 1
#define BOOST_PP_BOOL_96 1
#define BOOST_PP_BOOL_97 1
#define BOOST_PP_BOOL_98 1
#define BOOST_PP_BOOL_99 1
#define BOOST_PP_BOOL_100 1
#define BOOST_PP_BOOL_101 1
#define BOOST_PP_BOOL_102 1
#define BOOST_PP_BOOL_103 1
#define BOOST_PP_BOOL_104 1
#define BOOST_PP_BOOL_105 1
#define BOOST_PP_BOOL_106 1
#define BOOST_PP_BOOL_107 1
#define BOOST_PP_BOOL_108 1
#define BOOST_PP_BOOL_109 1
#define BOOST_PP_BOOL_110 1
#define BOOST_PP_BOOL_111 1
#define BOOST_PP_BOOL_112 1
#define BOOST_PP_BOOL_113 1
#define BOOST_PP_BOOL_114 1
#define BOOST_PP_BOOL_115 1
#define BOOST_PP_BOOL_116 1
#define BOOST_PP_BOOL_117 1
#define BOOST_PP_BOOL_118 1
#define BOOST_PP_BOOL_119 1
#define BOOST_PP_BOOL_120 1
#define BOOST_PP_BOOL_121 1
#define BOOST_PP_BOOL_122 1
#define BOOST_PP_BOOL_123 1
#define BOOST_PP_BOOL_124 1
#define BOOST_PP_BOOL_125 1
#define BOOST_PP_BOOL_126 1
#define BOOST_PP_BOOL_127 1
#define BOOST_PP_BOOL_128 1
#define BOOST_PP_BOOL_129 1
#define BOOST_PP_BOOL_130 1
#define BOOST_PP_BOOL_131 1
#define BOOST_PP_BOOL_132 1
#define BOOST_PP_BOOL_133 1
#define BOOST_PP_BOOL_134 1
#define BOOST_PP_BOOL_135 1
#define BOOST_PP_BOOL_136 1
#define BOOST_PP_BOOL_137 1
#define BOOST_PP_BOOL_138 1
#define BOOST_PP_BOOL_139 1
#define BOOST_PP_BOOL_140 1
#define BOOST_PP_BOOL_141 1
#define BOOST_PP_BOOL_142 1
#define BOOST_PP_BOOL_143 1
#define BOOST_PP_BOOL_144 1
#define BOOST_PP_BOOL_145 1
#define BOOST_PP_BOOL_146 1
#define BOOST_PP_BOOL_147 1
#define BOOST_PP_BOOL_148 1
#define BOOST_PP_BOOL_149 1
#define BOOST_PP_BOOL_150 1
#define BOOST_PP_BOOL_151 1
#define BOOST_PP_BOOL_152 1
#define BOOST_PP_BOOL_153 1
#define BOOST_PP_BOOL_154 1
#define BOOST_PP_BOOL_155 1
#define BOOST_PP_BOOL_156 1
#define BOOST_PP_BOOL_157 1
#define BOOST_PP_BOOL_158 1
#define BOOST_PP_BOOL_159 1
#define BOOST_PP_BOOL_160 1
#define BOOST_PP_BOOL_161 1
#define BOOST_PP_BOOL_162 1
#define BOOST_PP_BOOL_163 1
#define BOOST_PP_BOOL_164 1
#define BOOST_PP_BOOL_165 1
#define BOOST_PP_BOOL_166 1
#define BOOST_PP_BOOL_167 1
#define BOOST_PP_BOOL_168 1
#define BOOST_PP_BOOL_169 1
#define BOOST_PP_BOOL_170 1
#define BOOST_PP_BOOL_171 1
#define BOOST_PP_BOOL_172 1
#define BOOST_PP_BOOL_173 1
#define BOOST_PP_BOOL_174 1
#define BOOST_PP_BOOL_175 1
#define BOOST_PP_BOOL_176 1
#define BOOST_PP_BOOL_177 1
#define BOOST_PP_BOOL_178 1
#define BOOST_PP_BOOL_179 1
#define BOOST_PP_BOOL_180 1
#define BOOST_PP_BOOL_181 1
#define BOOST_PP_BOOL_182 1
#define BOOST_PP_BOOL_183 1
#define BOOST_PP_BOOL_184 1
#define BOOST_PP_BOOL_185 1
#define BOOST_PP_BOOL_186 1
#define BOOST_PP_BOOL_187 1
#define BOOST_PP_BOOL_188 1
#define BOOST_PP_BOOL_189 1
#define BOOST_PP_BOOL_190 1
#define BOOST_PP_BOOL_191 1
#define BOOST_PP_BOOL_192 1
#define BOOST_PP_BOOL_193 1
#define BOOST_PP_BOOL_194 1
#define BOOST_PP_BOOL_195 1
#define BOOST_PP_BOOL_196 1
#define BOOST_PP_BOOL_197 1
#define BOOST_PP_BOOL_198 1
#define BOOST_PP_BOOL_199 1
#define BOOST_PP_BOOL_200 1
#define BOOST_PP_BOOL_201 1
#define BOOST_PP_BOOL_202 1
#define BOOST_PP_BOOL_203 1
#define BOOST_PP_BOOL_204 1
#define BOOST_PP_BOOL_205 1
#define BOOST_PP_BOOL_206 1
#define BOOST_PP_BOOL_207 1
#define BOOST_PP_BOOL_208 1
#define BOOST_PP_BOOL_209 1
#define BOOST_PP_BOOL_210 1
#define BOOST_PP_BOOL_211 1
#define BOOST_PP_BOOL_212 1
#define BOOST_PP_BOOL_213 1
#define BOOST_PP_BOOL_214 1
#define BOOST_PP_BOOL_215 1
#define BOOST_PP_BOOL_216 1
#define BOOST_PP_BOOL_217 1
#define BOOST_PP_BOOL_218 1
#define BOOST_PP_BOOL_219 1
#define BOOST_PP_BOOL_220 1
#define BOOST_PP_BOOL_221 1
#define BOOST_PP_BOOL_222 1
#define BOOST_PP_BOOL_223 1
#define BOOST_PP_BOOL_224 1
#define BOOST_PP_BOOL_225 1
#define BOOST_PP_BOOL_226 1
#define BOOST_PP_BOOL_227 1
#define BOOST_PP_BOOL_228 1
#define BOOST_PP_BOOL_229 1
#define BOOST_PP_BOOL_230 1
#define BOOST_PP_BOOL_231 1
#define BOOST_PP_BOOL_232 1
#define BOOST_PP_BOOL_233 1
#define BOOST_PP_BOOL_234 1
#define BOOST_PP_BOOL_235 1
#define BOOST_PP_BOOL_236 1
#define BOOST_PP_BOOL_237 1
#define BOOST_PP_BOOL_238 1
#define BOOST_PP_BOOL_239 1
#define BOOST_PP_BOOL_240 1
#define BOOST_PP_BOOL_241 1
#define BOOST_PP_BOOL_242 1
#define BOOST_PP_BOOL_243 1
#define BOOST_PP_BOOL_244 1
#define BOOST_PP_BOOL_245 1
#define BOOST_PP_BOOL_246 1
#define BOOST_PP_BOOL_247 1
#define BOOST_PP_BOOL_248 1
#define BOOST_PP_BOOL_249 1
#define BOOST_PP_BOOL_250 1
#define BOOST_PP_BOOL_251 1
#define BOOST_PP_BOOL_252 1
#define BOOST_PP_BOOL_253 1
#define BOOST_PP_BOOL_254 1
#define BOOST_PP_BOOL_255 1
#define BOOST_PP_BOOL_256 1
# 20 "/usr/include/boost-1_41/boost/preprocessor/control/if.hpp" 2




#define BOOST_PP_IF(cond,t,f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
# 19 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/facilities/empty.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/facilities/empty.hpp"
#define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 



#define BOOST_PP_EMPTY() 
# 20 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma.hpp"
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 



#define BOOST_PP_COMMA() ,
# 21 "/usr/include/boost-1_41/boost/preprocessor/punctuation/comma_if.hpp" 2




#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
# 16 "/usr/include/boost-1_41/boost/preprocessor/comma_if.hpp" 2
# 46 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/repeat.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/repeat.hpp"
#define BOOST_PREPROCESSOR_REPEAT_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/repetition/repeat.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/repetition/repeat.hpp"
#define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP 



# 1 "/usr/include/boost-1_41/boost/preprocessor/debug/error.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/debug/error.hpp"
#define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP 







#define BOOST_PP_ERROR(code) BOOST_PP_CAT(BOOST_PP_ERROR_, code)


#define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS)
#define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW)
#define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW)
#define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW)
#define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW)
#define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO)
# 20 "/usr/include/boost-1_41/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 19 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp"
#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP 





#define BOOST_PP_AUTO_REC(pred,n) BOOST_PP_NODE_ENTRY_ ## n(pred)

#define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
#define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)

#define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
#define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
#define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
#define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
#define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
#define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
#define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
#define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
#define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
#define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
#define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
#define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
#define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
#define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
#define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
#define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
#define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
#define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
#define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
#define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
#define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
#define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
#define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
#define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
#define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
#define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
#define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
#define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
#define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
#define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
#define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
#define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
#define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
#define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
#define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
#define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
#define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
#define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
#define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
#define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
#define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
#define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
#define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
#define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
#define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
#define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
#define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
#define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
#define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
#define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
#define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
#define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
#define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
#define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
#define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
#define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
#define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
#define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
#define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
#define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
#define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
#define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
#define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
#define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
#define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
#define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
#define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
#define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
#define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
#define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
#define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
#define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
#define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
#define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
#define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
#define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
#define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
#define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
#define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
#define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
#define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
#define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
#define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
#define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
#define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
#define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
#define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
#define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
#define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
#define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
#define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
#define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
#define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
#define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
#define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
#define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
#define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
#define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
#define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
#define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
#define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
#define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
#define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
#define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
#define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
#define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
#define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
#define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
#define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
#define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
#define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
#define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
#define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
#define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
#define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
#define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
#define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
#define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
#define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
#define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
#define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
#define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
#define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
#define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
#define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
#define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
#define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
#define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
#define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
#define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
#define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
#define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
#define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
#define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
#define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
#define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
#define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
#define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
#define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
#define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
#define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
#define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
#define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
#define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
#define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
#define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
#define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
#define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
#define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
#define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
#define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
#define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
#define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
#define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
#define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
#define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
#define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
#define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
#define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
#define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
#define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
#define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
#define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
#define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
#define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
#define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
#define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
#define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
#define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
#define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
#define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
#define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
#define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
#define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
#define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
#define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
#define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
#define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
#define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
#define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
#define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
#define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
#define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
#define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
#define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
#define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
#define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
#define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
#define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
#define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
#define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
#define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
#define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
#define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
#define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
#define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
#define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
#define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
#define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
#define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
#define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
#define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
#define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
#define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
#define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
#define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
#define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
#define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
#define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
#define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
#define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
#define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
#define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
#define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
#define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
#define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
#define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
#define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
#define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
#define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
#define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
#define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
#define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
#define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
#define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
#define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
#define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
#define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
#define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
#define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
#define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
#define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
#define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
#define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
#define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
#define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
#define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
#define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
#define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
#define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
#define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
#define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
#define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
#define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
#define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
#define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
#define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
#define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
#define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
#define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
#define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
#define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
#define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
#define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
#define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
# 21 "/usr/include/boost-1_41/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/tuple/eat.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/tuple/eat.hpp"
#define BOOST_PREPROCESSOR_TUPLE_EAT_HPP 






#define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_I(size)





#define BOOST_PP_TUPLE_EAT_I(size) BOOST_PP_TUPLE_EAT_ ## size

#define BOOST_PP_TUPLE_EAT_0() 
#define BOOST_PP_TUPLE_EAT_1(a) 
#define BOOST_PP_TUPLE_EAT_2(a,b) 
#define BOOST_PP_TUPLE_EAT_3(a,b,c) 
#define BOOST_PP_TUPLE_EAT_4(a,b,c,d) 
#define BOOST_PP_TUPLE_EAT_5(a,b,c,d,e) 
#define BOOST_PP_TUPLE_EAT_6(a,b,c,d,e,f) 
#define BOOST_PP_TUPLE_EAT_7(a,b,c,d,e,f,g) 
#define BOOST_PP_TUPLE_EAT_8(a,b,c,d,e,f,g,h) 
#define BOOST_PP_TUPLE_EAT_9(a,b,c,d,e,f,g,h,i) 
#define BOOST_PP_TUPLE_EAT_10(a,b,c,d,e,f,g,h,i,j) 
#define BOOST_PP_TUPLE_EAT_11(a,b,c,d,e,f,g,h,i,j,k) 
#define BOOST_PP_TUPLE_EAT_12(a,b,c,d,e,f,g,h,i,j,k,l) 
#define BOOST_PP_TUPLE_EAT_13(a,b,c,d,e,f,g,h,i,j,k,l,m) 
#define BOOST_PP_TUPLE_EAT_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) 
#define BOOST_PP_TUPLE_EAT_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) 
#define BOOST_PP_TUPLE_EAT_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) 
#define BOOST_PP_TUPLE_EAT_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) 
#define BOOST_PP_TUPLE_EAT_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) 
#define BOOST_PP_TUPLE_EAT_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) 
#define BOOST_PP_TUPLE_EAT_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) 
#define BOOST_PP_TUPLE_EAT_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) 
#define BOOST_PP_TUPLE_EAT_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) 
#define BOOST_PP_TUPLE_EAT_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) 
#define BOOST_PP_TUPLE_EAT_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) 
#define BOOST_PP_TUPLE_EAT_25(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) 
# 22 "/usr/include/boost-1_41/boost/preprocessor/repetition/repeat.hpp" 2







#define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))

#define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL))

#define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c,m,d) 0

#define BOOST_PP_REPEAT_1(c,m,d) BOOST_PP_REPEAT_1_I(c, m, d)
#define BOOST_PP_REPEAT_2(c,m,d) BOOST_PP_REPEAT_2_I(c, m, d)
#define BOOST_PP_REPEAT_3(c,m,d) BOOST_PP_REPEAT_3_I(c, m, d)
#define BOOST_PP_REPEAT_4(c,m,d) BOOST_PP_ERROR(0x0003)

#define BOOST_PP_REPEAT_1_I(c,m,d) BOOST_PP_REPEAT_1_ ## c(m, d)
#define BOOST_PP_REPEAT_2_I(c,m,d) BOOST_PP_REPEAT_2_ ## c(m, d)
#define BOOST_PP_REPEAT_3_I(c,m,d) BOOST_PP_REPEAT_3_ ## c(m, d)

#define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1
#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2
#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3

#define BOOST_PP_REPEAT_1_0(m,d) 
#define BOOST_PP_REPEAT_1_1(m,d) m(2, 0, d)
#define BOOST_PP_REPEAT_1_2(m,d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
#define BOOST_PP_REPEAT_1_3(m,d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
#define BOOST_PP_REPEAT_1_4(m,d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d)
#define BOOST_PP_REPEAT_1_5(m,d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d)
#define BOOST_PP_REPEAT_1_6(m,d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d)
#define BOOST_PP_REPEAT_1_7(m,d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d)
#define BOOST_PP_REPEAT_1_8(m,d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d)
#define BOOST_PP_REPEAT_1_9(m,d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d)
#define BOOST_PP_REPEAT_1_10(m,d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d)
#define BOOST_PP_REPEAT_1_11(m,d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d)
#define BOOST_PP_REPEAT_1_12(m,d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d)
#define BOOST_PP_REPEAT_1_13(m,d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d)
#define BOOST_PP_REPEAT_1_14(m,d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d)
#define BOOST_PP_REPEAT_1_15(m,d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d)
#define BOOST_PP_REPEAT_1_16(m,d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d)
#define BOOST_PP_REPEAT_1_17(m,d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d)
#define BOOST_PP_REPEAT_1_18(m,d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d)
#define BOOST_PP_REPEAT_1_19(m,d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d)
#define BOOST_PP_REPEAT_1_20(m,d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d)
#define BOOST_PP_REPEAT_1_21(m,d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d)
#define BOOST_PP_REPEAT_1_22(m,d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d)
#define BOOST_PP_REPEAT_1_23(m,d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d)
#define BOOST_PP_REPEAT_1_24(m,d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d)
#define BOOST_PP_REPEAT_1_25(m,d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d)
#define BOOST_PP_REPEAT_1_26(m,d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d)
#define BOOST_PP_REPEAT_1_27(m,d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d)
#define BOOST_PP_REPEAT_1_28(m,d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d)
#define BOOST_PP_REPEAT_1_29(m,d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d)
#define BOOST_PP_REPEAT_1_30(m,d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d)
#define BOOST_PP_REPEAT_1_31(m,d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d)
#define BOOST_PP_REPEAT_1_32(m,d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d)
#define BOOST_PP_REPEAT_1_33(m,d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d)
#define BOOST_PP_REPEAT_1_34(m,d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d)
#define BOOST_PP_REPEAT_1_35(m,d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d)
#define BOOST_PP_REPEAT_1_36(m,d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d)
#define BOOST_PP_REPEAT_1_37(m,d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d)
#define BOOST_PP_REPEAT_1_38(m,d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d)
#define BOOST_PP_REPEAT_1_39(m,d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d)
#define BOOST_PP_REPEAT_1_40(m,d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d)
#define BOOST_PP_REPEAT_1_41(m,d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d)
#define BOOST_PP_REPEAT_1_42(m,d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d)
#define BOOST_PP_REPEAT_1_43(m,d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d)
#define BOOST_PP_REPEAT_1_44(m,d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d)
#define BOOST_PP_REPEAT_1_45(m,d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d)
#define BOOST_PP_REPEAT_1_46(m,d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d)
#define BOOST_PP_REPEAT_1_47(m,d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d)
#define BOOST_PP_REPEAT_1_48(m,d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d)
#define BOOST_PP_REPEAT_1_49(m,d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d)
#define BOOST_PP_REPEAT_1_50(m,d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d)
#define BOOST_PP_REPEAT_1_51(m,d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d)
#define BOOST_PP_REPEAT_1_52(m,d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d)
#define BOOST_PP_REPEAT_1_53(m,d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d)
#define BOOST_PP_REPEAT_1_54(m,d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d)
#define BOOST_PP_REPEAT_1_55(m,d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d)
#define BOOST_PP_REPEAT_1_56(m,d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d)
#define BOOST_PP_REPEAT_1_57(m,d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d)
#define BOOST_PP_REPEAT_1_58(m,d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d)
#define BOOST_PP_REPEAT_1_59(m,d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d)
#define BOOST_PP_REPEAT_1_60(m,d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d)
#define BOOST_PP_REPEAT_1_61(m,d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d)
#define BOOST_PP_REPEAT_1_62(m,d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d)
#define BOOST_PP_REPEAT_1_63(m,d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d)
#define BOOST_PP_REPEAT_1_64(m,d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d)
#define BOOST_PP_REPEAT_1_65(m,d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d)
#define BOOST_PP_REPEAT_1_66(m,d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d)
#define BOOST_PP_REPEAT_1_67(m,d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d)
#define BOOST_PP_REPEAT_1_68(m,d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d)
#define BOOST_PP_REPEAT_1_69(m,d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d)
#define BOOST_PP_REPEAT_1_70(m,d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d)
#define BOOST_PP_REPEAT_1_71(m,d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d)
#define BOOST_PP_REPEAT_1_72(m,d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d)
#define BOOST_PP_REPEAT_1_73(m,d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d)
#define BOOST_PP_REPEAT_1_74(m,d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d)
#define BOOST_PP_REPEAT_1_75(m,d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d)
#define BOOST_PP_REPEAT_1_76(m,d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d)
#define BOOST_PP_REPEAT_1_77(m,d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d)
#define BOOST_PP_REPEAT_1_78(m,d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d)
#define BOOST_PP_REPEAT_1_79(m,d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d)
#define BOOST_PP_REPEAT_1_80(m,d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d)
#define BOOST_PP_REPEAT_1_81(m,d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d)
#define BOOST_PP_REPEAT_1_82(m,d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d)
#define BOOST_PP_REPEAT_1_83(m,d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d)
#define BOOST_PP_REPEAT_1_84(m,d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d)
#define BOOST_PP_REPEAT_1_85(m,d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d)
#define BOOST_PP_REPEAT_1_86(m,d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d)
#define BOOST_PP_REPEAT_1_87(m,d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d)
#define BOOST_PP_REPEAT_1_88(m,d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d)
#define BOOST_PP_REPEAT_1_89(m,d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d)
#define BOOST_PP_REPEAT_1_90(m,d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d)
#define BOOST_PP_REPEAT_1_91(m,d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d)
#define BOOST_PP_REPEAT_1_92(m,d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d)
#define BOOST_PP_REPEAT_1_93(m,d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d)
#define BOOST_PP_REPEAT_1_94(m,d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d)
#define BOOST_PP_REPEAT_1_95(m,d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d)
#define BOOST_PP_REPEAT_1_96(m,d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d)
#define BOOST_PP_REPEAT_1_97(m,d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d)
#define BOOST_PP_REPEAT_1_98(m,d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d)
#define BOOST_PP_REPEAT_1_99(m,d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d)
#define BOOST_PP_REPEAT_1_100(m,d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d)
#define BOOST_PP_REPEAT_1_101(m,d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d)
#define BOOST_PP_REPEAT_1_102(m,d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d)
#define BOOST_PP_REPEAT_1_103(m,d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d)
#define BOOST_PP_REPEAT_1_104(m,d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d)
#define BOOST_PP_REPEAT_1_105(m,d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d)
#define BOOST_PP_REPEAT_1_106(m,d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d)
#define BOOST_PP_REPEAT_1_107(m,d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d)
#define BOOST_PP_REPEAT_1_108(m,d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d)
#define BOOST_PP_REPEAT_1_109(m,d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d)
#define BOOST_PP_REPEAT_1_110(m,d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d)
#define BOOST_PP_REPEAT_1_111(m,d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d)
#define BOOST_PP_REPEAT_1_112(m,d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d)
#define BOOST_PP_REPEAT_1_113(m,d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d)
#define BOOST_PP_REPEAT_1_114(m,d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d)
#define BOOST_PP_REPEAT_1_115(m,d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d)
#define BOOST_PP_REPEAT_1_116(m,d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d)
#define BOOST_PP_REPEAT_1_117(m,d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d)
#define BOOST_PP_REPEAT_1_118(m,d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d)
#define BOOST_PP_REPEAT_1_119(m,d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d)
#define BOOST_PP_REPEAT_1_120(m,d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d)
#define BOOST_PP_REPEAT_1_121(m,d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d)
#define BOOST_PP_REPEAT_1_122(m,d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d)
#define BOOST_PP_REPEAT_1_123(m,d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d)
#define BOOST_PP_REPEAT_1_124(m,d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d)
#define BOOST_PP_REPEAT_1_125(m,d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d)
#define BOOST_PP_REPEAT_1_126(m,d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d)
#define BOOST_PP_REPEAT_1_127(m,d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d)
#define BOOST_PP_REPEAT_1_128(m,d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d)
#define BOOST_PP_REPEAT_1_129(m,d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d)
#define BOOST_PP_REPEAT_1_130(m,d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d)
#define BOOST_PP_REPEAT_1_131(m,d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d)
#define BOOST_PP_REPEAT_1_132(m,d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d)
#define BOOST_PP_REPEAT_1_133(m,d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d)
#define BOOST_PP_REPEAT_1_134(m,d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d)
#define BOOST_PP_REPEAT_1_135(m,d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d)
#define BOOST_PP_REPEAT_1_136(m,d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d)
#define BOOST_PP_REPEAT_1_137(m,d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d)
#define BOOST_PP_REPEAT_1_138(m,d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d)
#define BOOST_PP_REPEAT_1_139(m,d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d)
#define BOOST_PP_REPEAT_1_140(m,d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d)
#define BOOST_PP_REPEAT_1_141(m,d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d)
#define BOOST_PP_REPEAT_1_142(m,d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d)
#define BOOST_PP_REPEAT_1_143(m,d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d)
#define BOOST_PP_REPEAT_1_144(m,d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d)
#define BOOST_PP_REPEAT_1_145(m,d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d)
#define BOOST_PP_REPEAT_1_146(m,d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d)
#define BOOST_PP_REPEAT_1_147(m,d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d)
#define BOOST_PP_REPEAT_1_148(m,d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d)
#define BOOST_PP_REPEAT_1_149(m,d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d)
#define BOOST_PP_REPEAT_1_150(m,d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d)
#define BOOST_PP_REPEAT_1_151(m,d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d)
#define BOOST_PP_REPEAT_1_152(m,d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d)
#define BOOST_PP_REPEAT_1_153(m,d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d)
#define BOOST_PP_REPEAT_1_154(m,d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d)
#define BOOST_PP_REPEAT_1_155(m,d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d)
#define BOOST_PP_REPEAT_1_156(m,d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d)
#define BOOST_PP_REPEAT_1_157(m,d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d)
#define BOOST_PP_REPEAT_1_158(m,d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d)
#define BOOST_PP_REPEAT_1_159(m,d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d)
#define BOOST_PP_REPEAT_1_160(m,d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d)
#define BOOST_PP_REPEAT_1_161(m,d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d)
#define BOOST_PP_REPEAT_1_162(m,d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d)
#define BOOST_PP_REPEAT_1_163(m,d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d)
#define BOOST_PP_REPEAT_1_164(m,d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d)
#define BOOST_PP_REPEAT_1_165(m,d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d)
#define BOOST_PP_REPEAT_1_166(m,d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d)
#define BOOST_PP_REPEAT_1_167(m,d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d)
#define BOOST_PP_REPEAT_1_168(m,d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d)
#define BOOST_PP_REPEAT_1_169(m,d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d)
#define BOOST_PP_REPEAT_1_170(m,d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d)
#define BOOST_PP_REPEAT_1_171(m,d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d)
#define BOOST_PP_REPEAT_1_172(m,d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d)
#define BOOST_PP_REPEAT_1_173(m,d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d)
#define BOOST_PP_REPEAT_1_174(m,d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d)
#define BOOST_PP_REPEAT_1_175(m,d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d)
#define BOOST_PP_REPEAT_1_176(m,d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d)
#define BOOST_PP_REPEAT_1_177(m,d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d)
#define BOOST_PP_REPEAT_1_178(m,d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d)
#define BOOST_PP_REPEAT_1_179(m,d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d)
#define BOOST_PP_REPEAT_1_180(m,d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d)
#define BOOST_PP_REPEAT_1_181(m,d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d)
#define BOOST_PP_REPEAT_1_182(m,d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d)
#define BOOST_PP_REPEAT_1_183(m,d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d)
#define BOOST_PP_REPEAT_1_184(m,d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d)
#define BOOST_PP_REPEAT_1_185(m,d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d)
#define BOOST_PP_REPEAT_1_186(m,d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d)
#define BOOST_PP_REPEAT_1_187(m,d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d)
#define BOOST_PP_REPEAT_1_188(m,d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d)
#define BOOST_PP_REPEAT_1_189(m,d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d)
#define BOOST_PP_REPEAT_1_190(m,d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d)
#define BOOST_PP_REPEAT_1_191(m,d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d)
#define BOOST_PP_REPEAT_1_192(m,d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d)
#define BOOST_PP_REPEAT_1_193(m,d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d)
#define BOOST_PP_REPEAT_1_194(m,d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d)
#define BOOST_PP_REPEAT_1_195(m,d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d)
#define BOOST_PP_REPEAT_1_196(m,d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d)
#define BOOST_PP_REPEAT_1_197(m,d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d)
#define BOOST_PP_REPEAT_1_198(m,d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d)
#define BOOST_PP_REPEAT_1_199(m,d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d)
#define BOOST_PP_REPEAT_1_200(m,d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d)
#define BOOST_PP_REPEAT_1_201(m,d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d)
#define BOOST_PP_REPEAT_1_202(m,d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d)
#define BOOST_PP_REPEAT_1_203(m,d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d)
#define BOOST_PP_REPEAT_1_204(m,d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d)
#define BOOST_PP_REPEAT_1_205(m,d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d)
#define BOOST_PP_REPEAT_1_206(m,d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d)
#define BOOST_PP_REPEAT_1_207(m,d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d)
#define BOOST_PP_REPEAT_1_208(m,d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d)
#define BOOST_PP_REPEAT_1_209(m,d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d)
#define BOOST_PP_REPEAT_1_210(m,d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d)
#define BOOST_PP_REPEAT_1_211(m,d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d)
#define BOOST_PP_REPEAT_1_212(m,d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d)
#define BOOST_PP_REPEAT_1_213(m,d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d)
#define BOOST_PP_REPEAT_1_214(m,d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d)
#define BOOST_PP_REPEAT_1_215(m,d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d)
#define BOOST_PP_REPEAT_1_216(m,d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d)
#define BOOST_PP_REPEAT_1_217(m,d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d)
#define BOOST_PP_REPEAT_1_218(m,d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d)
#define BOOST_PP_REPEAT_1_219(m,d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d)
#define BOOST_PP_REPEAT_1_220(m,d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d)
#define BOOST_PP_REPEAT_1_221(m,d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d)
#define BOOST_PP_REPEAT_1_222(m,d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d)
#define BOOST_PP_REPEAT_1_223(m,d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d)
#define BOOST_PP_REPEAT_1_224(m,d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d)
#define BOOST_PP_REPEAT_1_225(m,d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d)
#define BOOST_PP_REPEAT_1_226(m,d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d)
#define BOOST_PP_REPEAT_1_227(m,d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d)
#define BOOST_PP_REPEAT_1_228(m,d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d)
#define BOOST_PP_REPEAT_1_229(m,d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d)
#define BOOST_PP_REPEAT_1_230(m,d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d)
#define BOOST_PP_REPEAT_1_231(m,d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d)
#define BOOST_PP_REPEAT_1_232(m,d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d)
#define BOOST_PP_REPEAT_1_233(m,d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d)
#define BOOST_PP_REPEAT_1_234(m,d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d)
#define BOOST_PP_REPEAT_1_235(m,d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d)
#define BOOST_PP_REPEAT_1_236(m,d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d)
#define BOOST_PP_REPEAT_1_237(m,d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d)
#define BOOST_PP_REPEAT_1_238(m,d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d)
#define BOOST_PP_REPEAT_1_239(m,d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d)
#define BOOST_PP_REPEAT_1_240(m,d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d)
#define BOOST_PP_REPEAT_1_241(m,d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d)
#define BOOST_PP_REPEAT_1_242(m,d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d)
#define BOOST_PP_REPEAT_1_243(m,d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d)
#define BOOST_PP_REPEAT_1_244(m,d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d)
#define BOOST_PP_REPEAT_1_245(m,d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d)
#define BOOST_PP_REPEAT_1_246(m,d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d)
#define BOOST_PP_REPEAT_1_247(m,d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d)
#define BOOST_PP_REPEAT_1_248(m,d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d)
#define BOOST_PP_REPEAT_1_249(m,d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d)
#define BOOST_PP_REPEAT_1_250(m,d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d)
#define BOOST_PP_REPEAT_1_251(m,d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d)
#define BOOST_PP_REPEAT_1_252(m,d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d)
#define BOOST_PP_REPEAT_1_253(m,d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d)
#define BOOST_PP_REPEAT_1_254(m,d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d)
#define BOOST_PP_REPEAT_1_255(m,d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d)
#define BOOST_PP_REPEAT_1_256(m,d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d)

#define BOOST_PP_REPEAT_2_0(m,d) 
#define BOOST_PP_REPEAT_2_1(m,d) m(3, 0, d)
#define BOOST_PP_REPEAT_2_2(m,d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d)
#define BOOST_PP_REPEAT_2_3(m,d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d)
#define BOOST_PP_REPEAT_2_4(m,d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d)
#define BOOST_PP_REPEAT_2_5(m,d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d)
#define BOOST_PP_REPEAT_2_6(m,d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d)
#define BOOST_PP_REPEAT_2_7(m,d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d)
#define BOOST_PP_REPEAT_2_8(m,d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d)
#define BOOST_PP_REPEAT_2_9(m,d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d)
#define BOOST_PP_REPEAT_2_10(m,d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d)
#define BOOST_PP_REPEAT_2_11(m,d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d)
#define BOOST_PP_REPEAT_2_12(m,d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d)
#define BOOST_PP_REPEAT_2_13(m,d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d)
#define BOOST_PP_REPEAT_2_14(m,d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d)
#define BOOST_PP_REPEAT_2_15(m,d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d)
#define BOOST_PP_REPEAT_2_16(m,d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d)
#define BOOST_PP_REPEAT_2_17(m,d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d)
#define BOOST_PP_REPEAT_2_18(m,d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d)
#define BOOST_PP_REPEAT_2_19(m,d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d)
#define BOOST_PP_REPEAT_2_20(m,d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d)
#define BOOST_PP_REPEAT_2_21(m,d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d)
#define BOOST_PP_REPEAT_2_22(m,d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d)
#define BOOST_PP_REPEAT_2_23(m,d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d)
#define BOOST_PP_REPEAT_2_24(m,d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d)
#define BOOST_PP_REPEAT_2_25(m,d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d)
#define BOOST_PP_REPEAT_2_26(m,d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d)
#define BOOST_PP_REPEAT_2_27(m,d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d)
#define BOOST_PP_REPEAT_2_28(m,d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d)
#define BOOST_PP_REPEAT_2_29(m,d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d)
#define BOOST_PP_REPEAT_2_30(m,d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d)
#define BOOST_PP_REPEAT_2_31(m,d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d)
#define BOOST_PP_REPEAT_2_32(m,d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d)
#define BOOST_PP_REPEAT_2_33(m,d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d)
#define BOOST_PP_REPEAT_2_34(m,d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d)
#define BOOST_PP_REPEAT_2_35(m,d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d)
#define BOOST_PP_REPEAT_2_36(m,d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d)
#define BOOST_PP_REPEAT_2_37(m,d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d)
#define BOOST_PP_REPEAT_2_38(m,d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d)
#define BOOST_PP_REPEAT_2_39(m,d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d)
#define BOOST_PP_REPEAT_2_40(m,d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d)
#define BOOST_PP_REPEAT_2_41(m,d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d)
#define BOOST_PP_REPEAT_2_42(m,d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d)
#define BOOST_PP_REPEAT_2_43(m,d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d)
#define BOOST_PP_REPEAT_2_44(m,d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d)
#define BOOST_PP_REPEAT_2_45(m,d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d)
#define BOOST_PP_REPEAT_2_46(m,d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d)
#define BOOST_PP_REPEAT_2_47(m,d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d)
#define BOOST_PP_REPEAT_2_48(m,d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d)
#define BOOST_PP_REPEAT_2_49(m,d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d)
#define BOOST_PP_REPEAT_2_50(m,d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d)
#define BOOST_PP_REPEAT_2_51(m,d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d)
#define BOOST_PP_REPEAT_2_52(m,d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d)
#define BOOST_PP_REPEAT_2_53(m,d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d)
#define BOOST_PP_REPEAT_2_54(m,d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d)
#define BOOST_PP_REPEAT_2_55(m,d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d)
#define BOOST_PP_REPEAT_2_56(m,d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d)
#define BOOST_PP_REPEAT_2_57(m,d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d)
#define BOOST_PP_REPEAT_2_58(m,d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d)
#define BOOST_PP_REPEAT_2_59(m,d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d)
#define BOOST_PP_REPEAT_2_60(m,d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d)
#define BOOST_PP_REPEAT_2_61(m,d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d)
#define BOOST_PP_REPEAT_2_62(m,d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d)
#define BOOST_PP_REPEAT_2_63(m,d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d)
#define BOOST_PP_REPEAT_2_64(m,d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d)
#define BOOST_PP_REPEAT_2_65(m,d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d)
#define BOOST_PP_REPEAT_2_66(m,d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d)
#define BOOST_PP_REPEAT_2_67(m,d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d)
#define BOOST_PP_REPEAT_2_68(m,d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d)
#define BOOST_PP_REPEAT_2_69(m,d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d)
#define BOOST_PP_REPEAT_2_70(m,d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d)
#define BOOST_PP_REPEAT_2_71(m,d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d)
#define BOOST_PP_REPEAT_2_72(m,d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d)
#define BOOST_PP_REPEAT_2_73(m,d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d)
#define BOOST_PP_REPEAT_2_74(m,d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d)
#define BOOST_PP_REPEAT_2_75(m,d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d)
#define BOOST_PP_REPEAT_2_76(m,d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d)
#define BOOST_PP_REPEAT_2_77(m,d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d)
#define BOOST_PP_REPEAT_2_78(m,d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d)
#define BOOST_PP_REPEAT_2_79(m,d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d)
#define BOOST_PP_REPEAT_2_80(m,d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d)
#define BOOST_PP_REPEAT_2_81(m,d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d)
#define BOOST_PP_REPEAT_2_82(m,d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d)
#define BOOST_PP_REPEAT_2_83(m,d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d)
#define BOOST_PP_REPEAT_2_84(m,d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d)
#define BOOST_PP_REPEAT_2_85(m,d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d)
#define BOOST_PP_REPEAT_2_86(m,d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d)
#define BOOST_PP_REPEAT_2_87(m,d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d)
#define BOOST_PP_REPEAT_2_88(m,d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d)
#define BOOST_PP_REPEAT_2_89(m,d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d)
#define BOOST_PP_REPEAT_2_90(m,d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d)
#define BOOST_PP_REPEAT_2_91(m,d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d)
#define BOOST_PP_REPEAT_2_92(m,d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d)
#define BOOST_PP_REPEAT_2_93(m,d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d)
#define BOOST_PP_REPEAT_2_94(m,d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d)
#define BOOST_PP_REPEAT_2_95(m,d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d)
#define BOOST_PP_REPEAT_2_96(m,d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d)
#define BOOST_PP_REPEAT_2_97(m,d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d)
#define BOOST_PP_REPEAT_2_98(m,d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d)
#define BOOST_PP_REPEAT_2_99(m,d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d)
#define BOOST_PP_REPEAT_2_100(m,d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d)
#define BOOST_PP_REPEAT_2_101(m,d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d)
#define BOOST_PP_REPEAT_2_102(m,d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d)
#define BOOST_PP_REPEAT_2_103(m,d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d)
#define BOOST_PP_REPEAT_2_104(m,d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d)
#define BOOST_PP_REPEAT_2_105(m,d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d)
#define BOOST_PP_REPEAT_2_106(m,d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d)
#define BOOST_PP_REPEAT_2_107(m,d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d)
#define BOOST_PP_REPEAT_2_108(m,d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d)
#define BOOST_PP_REPEAT_2_109(m,d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d)
#define BOOST_PP_REPEAT_2_110(m,d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d)
#define BOOST_PP_REPEAT_2_111(m,d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d)
#define BOOST_PP_REPEAT_2_112(m,d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d)
#define BOOST_PP_REPEAT_2_113(m,d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d)
#define BOOST_PP_REPEAT_2_114(m,d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d)
#define BOOST_PP_REPEAT_2_115(m,d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d)
#define BOOST_PP_REPEAT_2_116(m,d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d)
#define BOOST_PP_REPEAT_2_117(m,d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d)
#define BOOST_PP_REPEAT_2_118(m,d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d)
#define BOOST_PP_REPEAT_2_119(m,d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d)
#define BOOST_PP_REPEAT_2_120(m,d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d)
#define BOOST_PP_REPEAT_2_121(m,d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d)
#define BOOST_PP_REPEAT_2_122(m,d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d)
#define BOOST_PP_REPEAT_2_123(m,d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d)
#define BOOST_PP_REPEAT_2_124(m,d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d)
#define BOOST_PP_REPEAT_2_125(m,d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d)
#define BOOST_PP_REPEAT_2_126(m,d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d)
#define BOOST_PP_REPEAT_2_127(m,d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d)
#define BOOST_PP_REPEAT_2_128(m,d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d)
#define BOOST_PP_REPEAT_2_129(m,d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d)
#define BOOST_PP_REPEAT_2_130(m,d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d)
#define BOOST_PP_REPEAT_2_131(m,d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d)
#define BOOST_PP_REPEAT_2_132(m,d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d)
#define BOOST_PP_REPEAT_2_133(m,d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d)
#define BOOST_PP_REPEAT_2_134(m,d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d)
#define BOOST_PP_REPEAT_2_135(m,d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d)
#define BOOST_PP_REPEAT_2_136(m,d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d)
#define BOOST_PP_REPEAT_2_137(m,d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d)
#define BOOST_PP_REPEAT_2_138(m,d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d)
#define BOOST_PP_REPEAT_2_139(m,d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d)
#define BOOST_PP_REPEAT_2_140(m,d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d)
#define BOOST_PP_REPEAT_2_141(m,d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d)
#define BOOST_PP_REPEAT_2_142(m,d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d)
#define BOOST_PP_REPEAT_2_143(m,d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d)
#define BOOST_PP_REPEAT_2_144(m,d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d)
#define BOOST_PP_REPEAT_2_145(m,d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d)
#define BOOST_PP_REPEAT_2_146(m,d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d)
#define BOOST_PP_REPEAT_2_147(m,d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d)
#define BOOST_PP_REPEAT_2_148(m,d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d)
#define BOOST_PP_REPEAT_2_149(m,d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d)
#define BOOST_PP_REPEAT_2_150(m,d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d)
#define BOOST_PP_REPEAT_2_151(m,d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d)
#define BOOST_PP_REPEAT_2_152(m,d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d)
#define BOOST_PP_REPEAT_2_153(m,d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d)
#define BOOST_PP_REPEAT_2_154(m,d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d)
#define BOOST_PP_REPEAT_2_155(m,d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d)
#define BOOST_PP_REPEAT_2_156(m,d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d)
#define BOOST_PP_REPEAT_2_157(m,d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d)
#define BOOST_PP_REPEAT_2_158(m,d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d)
#define BOOST_PP_REPEAT_2_159(m,d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d)
#define BOOST_PP_REPEAT_2_160(m,d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d)
#define BOOST_PP_REPEAT_2_161(m,d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d)
#define BOOST_PP_REPEAT_2_162(m,d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d)
#define BOOST_PP_REPEAT_2_163(m,d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d)
#define BOOST_PP_REPEAT_2_164(m,d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d)
#define BOOST_PP_REPEAT_2_165(m,d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d)
#define BOOST_PP_REPEAT_2_166(m,d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d)
#define BOOST_PP_REPEAT_2_167(m,d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d)
#define BOOST_PP_REPEAT_2_168(m,d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d)
#define BOOST_PP_REPEAT_2_169(m,d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d)
#define BOOST_PP_REPEAT_2_170(m,d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d)
#define BOOST_PP_REPEAT_2_171(m,d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d)
#define BOOST_PP_REPEAT_2_172(m,d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d)
#define BOOST_PP_REPEAT_2_173(m,d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d)
#define BOOST_PP_REPEAT_2_174(m,d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d)
#define BOOST_PP_REPEAT_2_175(m,d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d)
#define BOOST_PP_REPEAT_2_176(m,d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d)
#define BOOST_PP_REPEAT_2_177(m,d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d)
#define BOOST_PP_REPEAT_2_178(m,d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d)
#define BOOST_PP_REPEAT_2_179(m,d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d)
#define BOOST_PP_REPEAT_2_180(m,d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d)
#define BOOST_PP_REPEAT_2_181(m,d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d)
#define BOOST_PP_REPEAT_2_182(m,d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d)
#define BOOST_PP_REPEAT_2_183(m,d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d)
#define BOOST_PP_REPEAT_2_184(m,d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d)
#define BOOST_PP_REPEAT_2_185(m,d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d)
#define BOOST_PP_REPEAT_2_186(m,d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d)
#define BOOST_PP_REPEAT_2_187(m,d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d)
#define BOOST_PP_REPEAT_2_188(m,d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d)
#define BOOST_PP_REPEAT_2_189(m,d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d)
#define BOOST_PP_REPEAT_2_190(m,d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d)
#define BOOST_PP_REPEAT_2_191(m,d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d)
#define BOOST_PP_REPEAT_2_192(m,d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d)
#define BOOST_PP_REPEAT_2_193(m,d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d)
#define BOOST_PP_REPEAT_2_194(m,d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d)
#define BOOST_PP_REPEAT_2_195(m,d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d)
#define BOOST_PP_REPEAT_2_196(m,d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d)
#define BOOST_PP_REPEAT_2_197(m,d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d)
#define BOOST_PP_REPEAT_2_198(m,d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d)
#define BOOST_PP_REPEAT_2_199(m,d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d)
#define BOOST_PP_REPEAT_2_200(m,d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d)
#define BOOST_PP_REPEAT_2_201(m,d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d)
#define BOOST_PP_REPEAT_2_202(m,d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d)
#define BOOST_PP_REPEAT_2_203(m,d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d)
#define BOOST_PP_REPEAT_2_204(m,d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d)
#define BOOST_PP_REPEAT_2_205(m,d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d)
#define BOOST_PP_REPEAT_2_206(m,d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d)
#define BOOST_PP_REPEAT_2_207(m,d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d)
#define BOOST_PP_REPEAT_2_208(m,d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d)
#define BOOST_PP_REPEAT_2_209(m,d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d)
#define BOOST_PP_REPEAT_2_210(m,d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d)
#define BOOST_PP_REPEAT_2_211(m,d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d)
#define BOOST_PP_REPEAT_2_212(m,d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d)
#define BOOST_PP_REPEAT_2_213(m,d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d)
#define BOOST_PP_REPEAT_2_214(m,d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d)
#define BOOST_PP_REPEAT_2_215(m,d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d)
#define BOOST_PP_REPEAT_2_216(m,d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d)
#define BOOST_PP_REPEAT_2_217(m,d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d)
#define BOOST_PP_REPEAT_2_218(m,d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d)
#define BOOST_PP_REPEAT_2_219(m,d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d)
#define BOOST_PP_REPEAT_2_220(m,d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d)
#define BOOST_PP_REPEAT_2_221(m,d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d)
#define BOOST_PP_REPEAT_2_222(m,d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d)
#define BOOST_PP_REPEAT_2_223(m,d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d)
#define BOOST_PP_REPEAT_2_224(m,d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d)
#define BOOST_PP_REPEAT_2_225(m,d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d)
#define BOOST_PP_REPEAT_2_226(m,d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d)
#define BOOST_PP_REPEAT_2_227(m,d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d)
#define BOOST_PP_REPEAT_2_228(m,d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d)
#define BOOST_PP_REPEAT_2_229(m,d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d)
#define BOOST_PP_REPEAT_2_230(m,d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d)
#define BOOST_PP_REPEAT_2_231(m,d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d)
#define BOOST_PP_REPEAT_2_232(m,d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d)
#define BOOST_PP_REPEAT_2_233(m,d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d)
#define BOOST_PP_REPEAT_2_234(m,d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d)
#define BOOST_PP_REPEAT_2_235(m,d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d)
#define BOOST_PP_REPEAT_2_236(m,d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d)
#define BOOST_PP_REPEAT_2_237(m,d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d)
#define BOOST_PP_REPEAT_2_238(m,d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d)
#define BOOST_PP_REPEAT_2_239(m,d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d)
#define BOOST_PP_REPEAT_2_240(m,d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d)
#define BOOST_PP_REPEAT_2_241(m,d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d)
#define BOOST_PP_REPEAT_2_242(m,d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d)
#define BOOST_PP_REPEAT_2_243(m,d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d)
#define BOOST_PP_REPEAT_2_244(m,d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d)
#define BOOST_PP_REPEAT_2_245(m,d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d)
#define BOOST_PP_REPEAT_2_246(m,d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d)
#define BOOST_PP_REPEAT_2_247(m,d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d)
#define BOOST_PP_REPEAT_2_248(m,d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d)
#define BOOST_PP_REPEAT_2_249(m,d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d)
#define BOOST_PP_REPEAT_2_250(m,d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d)
#define BOOST_PP_REPEAT_2_251(m,d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d)
#define BOOST_PP_REPEAT_2_252(m,d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d)
#define BOOST_PP_REPEAT_2_253(m,d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d)
#define BOOST_PP_REPEAT_2_254(m,d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d)
#define BOOST_PP_REPEAT_2_255(m,d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d)
#define BOOST_PP_REPEAT_2_256(m,d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d)

#define BOOST_PP_REPEAT_3_0(m,d) 
#define BOOST_PP_REPEAT_3_1(m,d) m(4, 0, d)
#define BOOST_PP_REPEAT_3_2(m,d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d)
#define BOOST_PP_REPEAT_3_3(m,d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d)
#define BOOST_PP_REPEAT_3_4(m,d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d)
#define BOOST_PP_REPEAT_3_5(m,d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d)
#define BOOST_PP_REPEAT_3_6(m,d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d)
#define BOOST_PP_REPEAT_3_7(m,d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d)
#define BOOST_PP_REPEAT_3_8(m,d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d)
#define BOOST_PP_REPEAT_3_9(m,d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d)
#define BOOST_PP_REPEAT_3_10(m,d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d)
#define BOOST_PP_REPEAT_3_11(m,d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d)
#define BOOST_PP_REPEAT_3_12(m,d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d)
#define BOOST_PP_REPEAT_3_13(m,d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d)
#define BOOST_PP_REPEAT_3_14(m,d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d)
#define BOOST_PP_REPEAT_3_15(m,d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d)
#define BOOST_PP_REPEAT_3_16(m,d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d)
#define BOOST_PP_REPEAT_3_17(m,d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d)
#define BOOST_PP_REPEAT_3_18(m,d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d)
#define BOOST_PP_REPEAT_3_19(m,d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d)
#define BOOST_PP_REPEAT_3_20(m,d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d)
#define BOOST_PP_REPEAT_3_21(m,d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d)
#define BOOST_PP_REPEAT_3_22(m,d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d)
#define BOOST_PP_REPEAT_3_23(m,d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d)
#define BOOST_PP_REPEAT_3_24(m,d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d)
#define BOOST_PP_REPEAT_3_25(m,d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d)
#define BOOST_PP_REPEAT_3_26(m,d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d)
#define BOOST_PP_REPEAT_3_27(m,d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d)
#define BOOST_PP_REPEAT_3_28(m,d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d)
#define BOOST_PP_REPEAT_3_29(m,d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d)
#define BOOST_PP_REPEAT_3_30(m,d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d)
#define BOOST_PP_REPEAT_3_31(m,d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d)
#define BOOST_PP_REPEAT_3_32(m,d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d)
#define BOOST_PP_REPEAT_3_33(m,d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d)
#define BOOST_PP_REPEAT_3_34(m,d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d)
#define BOOST_PP_REPEAT_3_35(m,d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d)
#define BOOST_PP_REPEAT_3_36(m,d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d)
#define BOOST_PP_REPEAT_3_37(m,d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d)
#define BOOST_PP_REPEAT_3_38(m,d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d)
#define BOOST_PP_REPEAT_3_39(m,d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d)
#define BOOST_PP_REPEAT_3_40(m,d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d)
#define BOOST_PP_REPEAT_3_41(m,d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d)
#define BOOST_PP_REPEAT_3_42(m,d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d)
#define BOOST_PP_REPEAT_3_43(m,d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d)
#define BOOST_PP_REPEAT_3_44(m,d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d)
#define BOOST_PP_REPEAT_3_45(m,d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d)
#define BOOST_PP_REPEAT_3_46(m,d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d)
#define BOOST_PP_REPEAT_3_47(m,d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d)
#define BOOST_PP_REPEAT_3_48(m,d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d)
#define BOOST_PP_REPEAT_3_49(m,d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d)
#define BOOST_PP_REPEAT_3_50(m,d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d)
#define BOOST_PP_REPEAT_3_51(m,d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d)
#define BOOST_PP_REPEAT_3_52(m,d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d)
#define BOOST_PP_REPEAT_3_53(m,d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d)
#define BOOST_PP_REPEAT_3_54(m,d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d)
#define BOOST_PP_REPEAT_3_55(m,d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d)
#define BOOST_PP_REPEAT_3_56(m,d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d)
#define BOOST_PP_REPEAT_3_57(m,d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d)
#define BOOST_PP_REPEAT_3_58(m,d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d)
#define BOOST_PP_REPEAT_3_59(m,d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d)
#define BOOST_PP_REPEAT_3_60(m,d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d)
#define BOOST_PP_REPEAT_3_61(m,d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d)
#define BOOST_PP_REPEAT_3_62(m,d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d)
#define BOOST_PP_REPEAT_3_63(m,d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d)
#define BOOST_PP_REPEAT_3_64(m,d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d)
#define BOOST_PP_REPEAT_3_65(m,d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d)
#define BOOST_PP_REPEAT_3_66(m,d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d)
#define BOOST_PP_REPEAT_3_67(m,d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d)
#define BOOST_PP_REPEAT_3_68(m,d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d)
#define BOOST_PP_REPEAT_3_69(m,d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d)
#define BOOST_PP_REPEAT_3_70(m,d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d)
#define BOOST_PP_REPEAT_3_71(m,d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d)
#define BOOST_PP_REPEAT_3_72(m,d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d)
#define BOOST_PP_REPEAT_3_73(m,d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d)
#define BOOST_PP_REPEAT_3_74(m,d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d)
#define BOOST_PP_REPEAT_3_75(m,d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d)
#define BOOST_PP_REPEAT_3_76(m,d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d)
#define BOOST_PP_REPEAT_3_77(m,d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d)
#define BOOST_PP_REPEAT_3_78(m,d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d)
#define BOOST_PP_REPEAT_3_79(m,d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d)
#define BOOST_PP_REPEAT_3_80(m,d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d)
#define BOOST_PP_REPEAT_3_81(m,d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d)
#define BOOST_PP_REPEAT_3_82(m,d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d)
#define BOOST_PP_REPEAT_3_83(m,d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d)
#define BOOST_PP_REPEAT_3_84(m,d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d)
#define BOOST_PP_REPEAT_3_85(m,d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d)
#define BOOST_PP_REPEAT_3_86(m,d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d)
#define BOOST_PP_REPEAT_3_87(m,d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d)
#define BOOST_PP_REPEAT_3_88(m,d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d)
#define BOOST_PP_REPEAT_3_89(m,d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d)
#define BOOST_PP_REPEAT_3_90(m,d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d)
#define BOOST_PP_REPEAT_3_91(m,d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d)
#define BOOST_PP_REPEAT_3_92(m,d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d)
#define BOOST_PP_REPEAT_3_93(m,d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d)
#define BOOST_PP_REPEAT_3_94(m,d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d)
#define BOOST_PP_REPEAT_3_95(m,d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d)
#define BOOST_PP_REPEAT_3_96(m,d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d)
#define BOOST_PP_REPEAT_3_97(m,d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d)
#define BOOST_PP_REPEAT_3_98(m,d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d)
#define BOOST_PP_REPEAT_3_99(m,d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d)
#define BOOST_PP_REPEAT_3_100(m,d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d)
#define BOOST_PP_REPEAT_3_101(m,d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d)
#define BOOST_PP_REPEAT_3_102(m,d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d)
#define BOOST_PP_REPEAT_3_103(m,d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d)
#define BOOST_PP_REPEAT_3_104(m,d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d)
#define BOOST_PP_REPEAT_3_105(m,d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d)
#define BOOST_PP_REPEAT_3_106(m,d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d)
#define BOOST_PP_REPEAT_3_107(m,d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d)
#define BOOST_PP_REPEAT_3_108(m,d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d)
#define BOOST_PP_REPEAT_3_109(m,d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d)
#define BOOST_PP_REPEAT_3_110(m,d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d)
#define BOOST_PP_REPEAT_3_111(m,d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d)
#define BOOST_PP_REPEAT_3_112(m,d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d)
#define BOOST_PP_REPEAT_3_113(m,d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d)
#define BOOST_PP_REPEAT_3_114(m,d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d)
#define BOOST_PP_REPEAT_3_115(m,d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d)
#define BOOST_PP_REPEAT_3_116(m,d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d)
#define BOOST_PP_REPEAT_3_117(m,d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d)
#define BOOST_PP_REPEAT_3_118(m,d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d)
#define BOOST_PP_REPEAT_3_119(m,d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d)
#define BOOST_PP_REPEAT_3_120(m,d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d)
#define BOOST_PP_REPEAT_3_121(m,d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d)
#define BOOST_PP_REPEAT_3_122(m,d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d)
#define BOOST_PP_REPEAT_3_123(m,d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d)
#define BOOST_PP_REPEAT_3_124(m,d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d)
#define BOOST_PP_REPEAT_3_125(m,d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d)
#define BOOST_PP_REPEAT_3_126(m,d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d)
#define BOOST_PP_REPEAT_3_127(m,d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d)
#define BOOST_PP_REPEAT_3_128(m,d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d)
#define BOOST_PP_REPEAT_3_129(m,d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d)
#define BOOST_PP_REPEAT_3_130(m,d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d)
#define BOOST_PP_REPEAT_3_131(m,d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d)
#define BOOST_PP_REPEAT_3_132(m,d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d)
#define BOOST_PP_REPEAT_3_133(m,d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d)
#define BOOST_PP_REPEAT_3_134(m,d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d)
#define BOOST_PP_REPEAT_3_135(m,d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d)
#define BOOST_PP_REPEAT_3_136(m,d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d)
#define BOOST_PP_REPEAT_3_137(m,d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d)
#define BOOST_PP_REPEAT_3_138(m,d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d)
#define BOOST_PP_REPEAT_3_139(m,d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d)
#define BOOST_PP_REPEAT_3_140(m,d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d)
#define BOOST_PP_REPEAT_3_141(m,d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d)
#define BOOST_PP_REPEAT_3_142(m,d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d)
#define BOOST_PP_REPEAT_3_143(m,d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d)
#define BOOST_PP_REPEAT_3_144(m,d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d)
#define BOOST_PP_REPEAT_3_145(m,d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d)
#define BOOST_PP_REPEAT_3_146(m,d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d)
#define BOOST_PP_REPEAT_3_147(m,d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d)
#define BOOST_PP_REPEAT_3_148(m,d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d)
#define BOOST_PP_REPEAT_3_149(m,d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d)
#define BOOST_PP_REPEAT_3_150(m,d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d)
#define BOOST_PP_REPEAT_3_151(m,d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d)
#define BOOST_PP_REPEAT_3_152(m,d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d)
#define BOOST_PP_REPEAT_3_153(m,d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d)
#define BOOST_PP_REPEAT_3_154(m,d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d)
#define BOOST_PP_REPEAT_3_155(m,d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d)
#define BOOST_PP_REPEAT_3_156(m,d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d)
#define BOOST_PP_REPEAT_3_157(m,d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d)
#define BOOST_PP_REPEAT_3_158(m,d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d)
#define BOOST_PP_REPEAT_3_159(m,d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d)
#define BOOST_PP_REPEAT_3_160(m,d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d)
#define BOOST_PP_REPEAT_3_161(m,d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d)
#define BOOST_PP_REPEAT_3_162(m,d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d)
#define BOOST_PP_REPEAT_3_163(m,d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d)
#define BOOST_PP_REPEAT_3_164(m,d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d)
#define BOOST_PP_REPEAT_3_165(m,d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d)
#define BOOST_PP_REPEAT_3_166(m,d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d)
#define BOOST_PP_REPEAT_3_167(m,d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d)
#define BOOST_PP_REPEAT_3_168(m,d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d)
#define BOOST_PP_REPEAT_3_169(m,d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d)
#define BOOST_PP_REPEAT_3_170(m,d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d)
#define BOOST_PP_REPEAT_3_171(m,d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d)
#define BOOST_PP_REPEAT_3_172(m,d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d)
#define BOOST_PP_REPEAT_3_173(m,d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d)
#define BOOST_PP_REPEAT_3_174(m,d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d)
#define BOOST_PP_REPEAT_3_175(m,d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d)
#define BOOST_PP_REPEAT_3_176(m,d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d)
#define BOOST_PP_REPEAT_3_177(m,d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d)
#define BOOST_PP_REPEAT_3_178(m,d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d)
#define BOOST_PP_REPEAT_3_179(m,d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d)
#define BOOST_PP_REPEAT_3_180(m,d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d)
#define BOOST_PP_REPEAT_3_181(m,d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d)
#define BOOST_PP_REPEAT_3_182(m,d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d)
#define BOOST_PP_REPEAT_3_183(m,d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d)
#define BOOST_PP_REPEAT_3_184(m,d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d)
#define BOOST_PP_REPEAT_3_185(m,d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d)
#define BOOST_PP_REPEAT_3_186(m,d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d)
#define BOOST_PP_REPEAT_3_187(m,d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d)
#define BOOST_PP_REPEAT_3_188(m,d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d)
#define BOOST_PP_REPEAT_3_189(m,d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d)
#define BOOST_PP_REPEAT_3_190(m,d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d)
#define BOOST_PP_REPEAT_3_191(m,d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d)
#define BOOST_PP_REPEAT_3_192(m,d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d)
#define BOOST_PP_REPEAT_3_193(m,d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d)
#define BOOST_PP_REPEAT_3_194(m,d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d)
#define BOOST_PP_REPEAT_3_195(m,d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d)
#define BOOST_PP_REPEAT_3_196(m,d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d)
#define BOOST_PP_REPEAT_3_197(m,d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d)
#define BOOST_PP_REPEAT_3_198(m,d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d)
#define BOOST_PP_REPEAT_3_199(m,d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d)
#define BOOST_PP_REPEAT_3_200(m,d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d)
#define BOOST_PP_REPEAT_3_201(m,d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d)
#define BOOST_PP_REPEAT_3_202(m,d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d)
#define BOOST_PP_REPEAT_3_203(m,d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d)
#define BOOST_PP_REPEAT_3_204(m,d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d)
#define BOOST_PP_REPEAT_3_205(m,d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d)
#define BOOST_PP_REPEAT_3_206(m,d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d)
#define BOOST_PP_REPEAT_3_207(m,d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d)
#define BOOST_PP_REPEAT_3_208(m,d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d)
#define BOOST_PP_REPEAT_3_209(m,d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d)
#define BOOST_PP_REPEAT_3_210(m,d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d)
#define BOOST_PP_REPEAT_3_211(m,d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d)
#define BOOST_PP_REPEAT_3_212(m,d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d)
#define BOOST_PP_REPEAT_3_213(m,d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d)
#define BOOST_PP_REPEAT_3_214(m,d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d)
#define BOOST_PP_REPEAT_3_215(m,d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d)
#define BOOST_PP_REPEAT_3_216(m,d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d)
#define BOOST_PP_REPEAT_3_217(m,d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d)
#define BOOST_PP_REPEAT_3_218(m,d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d)
#define BOOST_PP_REPEAT_3_219(m,d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d)
#define BOOST_PP_REPEAT_3_220(m,d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d)
#define BOOST_PP_REPEAT_3_221(m,d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d)
#define BOOST_PP_REPEAT_3_222(m,d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d)
#define BOOST_PP_REPEAT_3_223(m,d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d)
#define BOOST_PP_REPEAT_3_224(m,d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d)
#define BOOST_PP_REPEAT_3_225(m,d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d)
#define BOOST_PP_REPEAT_3_226(m,d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d)
#define BOOST_PP_REPEAT_3_227(m,d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d)
#define BOOST_PP_REPEAT_3_228(m,d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d)
#define BOOST_PP_REPEAT_3_229(m,d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d)
#define BOOST_PP_REPEAT_3_230(m,d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d)
#define BOOST_PP_REPEAT_3_231(m,d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d)
#define BOOST_PP_REPEAT_3_232(m,d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d)
#define BOOST_PP_REPEAT_3_233(m,d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d)
#define BOOST_PP_REPEAT_3_234(m,d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d)
#define BOOST_PP_REPEAT_3_235(m,d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d)
#define BOOST_PP_REPEAT_3_236(m,d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d)
#define BOOST_PP_REPEAT_3_237(m,d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d)
#define BOOST_PP_REPEAT_3_238(m,d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d)
#define BOOST_PP_REPEAT_3_239(m,d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d)
#define BOOST_PP_REPEAT_3_240(m,d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d)
#define BOOST_PP_REPEAT_3_241(m,d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d)
#define BOOST_PP_REPEAT_3_242(m,d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d)
#define BOOST_PP_REPEAT_3_243(m,d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d)
#define BOOST_PP_REPEAT_3_244(m,d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d)
#define BOOST_PP_REPEAT_3_245(m,d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d)
#define BOOST_PP_REPEAT_3_246(m,d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d)
#define BOOST_PP_REPEAT_3_247(m,d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d)
#define BOOST_PP_REPEAT_3_248(m,d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d)
#define BOOST_PP_REPEAT_3_249(m,d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d)
#define BOOST_PP_REPEAT_3_250(m,d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d)
#define BOOST_PP_REPEAT_3_251(m,d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d)
#define BOOST_PP_REPEAT_3_252(m,d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d)
#define BOOST_PP_REPEAT_3_253(m,d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d)
#define BOOST_PP_REPEAT_3_254(m,d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d)
#define BOOST_PP_REPEAT_3_255(m,d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d)
#define BOOST_PP_REPEAT_3_256(m,d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d)
# 16 "/usr/include/boost-1_41/boost/preprocessor/repeat.hpp" 2
# 47 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/inc.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/inc.hpp"
#define BOOST_PREPROCESSOR_INC_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/inc.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/inc.hpp"
#define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP 






#define BOOST_PP_INC(x) BOOST_PP_INC_I(x)





#define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x

#define BOOST_PP_INC_0 1
#define BOOST_PP_INC_1 2
#define BOOST_PP_INC_2 3
#define BOOST_PP_INC_3 4
#define BOOST_PP_INC_4 5
#define BOOST_PP_INC_5 6
#define BOOST_PP_INC_6 7
#define BOOST_PP_INC_7 8
#define BOOST_PP_INC_8 9
#define BOOST_PP_INC_9 10
#define BOOST_PP_INC_10 11
#define BOOST_PP_INC_11 12
#define BOOST_PP_INC_12 13
#define BOOST_PP_INC_13 14
#define BOOST_PP_INC_14 15
#define BOOST_PP_INC_15 16
#define BOOST_PP_INC_16 17
#define BOOST_PP_INC_17 18
#define BOOST_PP_INC_18 19
#define BOOST_PP_INC_19 20
#define BOOST_PP_INC_20 21
#define BOOST_PP_INC_21 22
#define BOOST_PP_INC_22 23
#define BOOST_PP_INC_23 24
#define BOOST_PP_INC_24 25
#define BOOST_PP_INC_25 26
#define BOOST_PP_INC_26 27
#define BOOST_PP_INC_27 28
#define BOOST_PP_INC_28 29
#define BOOST_PP_INC_29 30
#define BOOST_PP_INC_30 31
#define BOOST_PP_INC_31 32
#define BOOST_PP_INC_32 33
#define BOOST_PP_INC_33 34
#define BOOST_PP_INC_34 35
#define BOOST_PP_INC_35 36
#define BOOST_PP_INC_36 37
#define BOOST_PP_INC_37 38
#define BOOST_PP_INC_38 39
#define BOOST_PP_INC_39 40
#define BOOST_PP_INC_40 41
#define BOOST_PP_INC_41 42
#define BOOST_PP_INC_42 43
#define BOOST_PP_INC_43 44
#define BOOST_PP_INC_44 45
#define BOOST_PP_INC_45 46
#define BOOST_PP_INC_46 47
#define BOOST_PP_INC_47 48
#define BOOST_PP_INC_48 49
#define BOOST_PP_INC_49 50
#define BOOST_PP_INC_50 51
#define BOOST_PP_INC_51 52
#define BOOST_PP_INC_52 53
#define BOOST_PP_INC_53 54
#define BOOST_PP_INC_54 55
#define BOOST_PP_INC_55 56
#define BOOST_PP_INC_56 57
#define BOOST_PP_INC_57 58
#define BOOST_PP_INC_58 59
#define BOOST_PP_INC_59 60
#define BOOST_PP_INC_60 61
#define BOOST_PP_INC_61 62
#define BOOST_PP_INC_62 63
#define BOOST_PP_INC_63 64
#define BOOST_PP_INC_64 65
#define BOOST_PP_INC_65 66
#define BOOST_PP_INC_66 67
#define BOOST_PP_INC_67 68
#define BOOST_PP_INC_68 69
#define BOOST_PP_INC_69 70
#define BOOST_PP_INC_70 71
#define BOOST_PP_INC_71 72
#define BOOST_PP_INC_72 73
#define BOOST_PP_INC_73 74
#define BOOST_PP_INC_74 75
#define BOOST_PP_INC_75 76
#define BOOST_PP_INC_76 77
#define BOOST_PP_INC_77 78
#define BOOST_PP_INC_78 79
#define BOOST_PP_INC_79 80
#define BOOST_PP_INC_80 81
#define BOOST_PP_INC_81 82
#define BOOST_PP_INC_82 83
#define BOOST_PP_INC_83 84
#define BOOST_PP_INC_84 85
#define BOOST_PP_INC_85 86
#define BOOST_PP_INC_86 87
#define BOOST_PP_INC_87 88
#define BOOST_PP_INC_88 89
#define BOOST_PP_INC_89 90
#define BOOST_PP_INC_90 91
#define BOOST_PP_INC_91 92
#define BOOST_PP_INC_92 93
#define BOOST_PP_INC_93 94
#define BOOST_PP_INC_94 95
#define BOOST_PP_INC_95 96
#define BOOST_PP_INC_96 97
#define BOOST_PP_INC_97 98
#define BOOST_PP_INC_98 99
#define BOOST_PP_INC_99 100
#define BOOST_PP_INC_100 101
#define BOOST_PP_INC_101 102
#define BOOST_PP_INC_102 103
#define BOOST_PP_INC_103 104
#define BOOST_PP_INC_104 105
#define BOOST_PP_INC_105 106
#define BOOST_PP_INC_106 107
#define BOOST_PP_INC_107 108
#define BOOST_PP_INC_108 109
#define BOOST_PP_INC_109 110
#define BOOST_PP_INC_110 111
#define BOOST_PP_INC_111 112
#define BOOST_PP_INC_112 113
#define BOOST_PP_INC_113 114
#define BOOST_PP_INC_114 115
#define BOOST_PP_INC_115 116
#define BOOST_PP_INC_116 117
#define BOOST_PP_INC_117 118
#define BOOST_PP_INC_118 119
#define BOOST_PP_INC_119 120
#define BOOST_PP_INC_120 121
#define BOOST_PP_INC_121 122
#define BOOST_PP_INC_122 123
#define BOOST_PP_INC_123 124
#define BOOST_PP_INC_124 125
#define BOOST_PP_INC_125 126
#define BOOST_PP_INC_126 127
#define BOOST_PP_INC_127 128
#define BOOST_PP_INC_128 129
#define BOOST_PP_INC_129 130
#define BOOST_PP_INC_130 131
#define BOOST_PP_INC_131 132
#define BOOST_PP_INC_132 133
#define BOOST_PP_INC_133 134
#define BOOST_PP_INC_134 135
#define BOOST_PP_INC_135 136
#define BOOST_PP_INC_136 137
#define BOOST_PP_INC_137 138
#define BOOST_PP_INC_138 139
#define BOOST_PP_INC_139 140
#define BOOST_PP_INC_140 141
#define BOOST_PP_INC_141 142
#define BOOST_PP_INC_142 143
#define BOOST_PP_INC_143 144
#define BOOST_PP_INC_144 145
#define BOOST_PP_INC_145 146
#define BOOST_PP_INC_146 147
#define BOOST_PP_INC_147 148
#define BOOST_PP_INC_148 149
#define BOOST_PP_INC_149 150
#define BOOST_PP_INC_150 151
#define BOOST_PP_INC_151 152
#define BOOST_PP_INC_152 153
#define BOOST_PP_INC_153 154
#define BOOST_PP_INC_154 155
#define BOOST_PP_INC_155 156
#define BOOST_PP_INC_156 157
#define BOOST_PP_INC_157 158
#define BOOST_PP_INC_158 159
#define BOOST_PP_INC_159 160
#define BOOST_PP_INC_160 161
#define BOOST_PP_INC_161 162
#define BOOST_PP_INC_162 163
#define BOOST_PP_INC_163 164
#define BOOST_PP_INC_164 165
#define BOOST_PP_INC_165 166
#define BOOST_PP_INC_166 167
#define BOOST_PP_INC_167 168
#define BOOST_PP_INC_168 169
#define BOOST_PP_INC_169 170
#define BOOST_PP_INC_170 171
#define BOOST_PP_INC_171 172
#define BOOST_PP_INC_172 173
#define BOOST_PP_INC_173 174
#define BOOST_PP_INC_174 175
#define BOOST_PP_INC_175 176
#define BOOST_PP_INC_176 177
#define BOOST_PP_INC_177 178
#define BOOST_PP_INC_178 179
#define BOOST_PP_INC_179 180
#define BOOST_PP_INC_180 181
#define BOOST_PP_INC_181 182
#define BOOST_PP_INC_182 183
#define BOOST_PP_INC_183 184
#define BOOST_PP_INC_184 185
#define BOOST_PP_INC_185 186
#define BOOST_PP_INC_186 187
#define BOOST_PP_INC_187 188
#define BOOST_PP_INC_188 189
#define BOOST_PP_INC_189 190
#define BOOST_PP_INC_190 191
#define BOOST_PP_INC_191 192
#define BOOST_PP_INC_192 193
#define BOOST_PP_INC_193 194
#define BOOST_PP_INC_194 195
#define BOOST_PP_INC_195 196
#define BOOST_PP_INC_196 197
#define BOOST_PP_INC_197 198
#define BOOST_PP_INC_198 199
#define BOOST_PP_INC_199 200
#define BOOST_PP_INC_200 201
#define BOOST_PP_INC_201 202
#define BOOST_PP_INC_202 203
#define BOOST_PP_INC_203 204
#define BOOST_PP_INC_204 205
#define BOOST_PP_INC_205 206
#define BOOST_PP_INC_206 207
#define BOOST_PP_INC_207 208
#define BOOST_PP_INC_208 209
#define BOOST_PP_INC_209 210
#define BOOST_PP_INC_210 211
#define BOOST_PP_INC_211 212
#define BOOST_PP_INC_212 213
#define BOOST_PP_INC_213 214
#define BOOST_PP_INC_214 215
#define BOOST_PP_INC_215 216
#define BOOST_PP_INC_216 217
#define BOOST_PP_INC_217 218
#define BOOST_PP_INC_218 219
#define BOOST_PP_INC_219 220
#define BOOST_PP_INC_220 221
#define BOOST_PP_INC_221 222
#define BOOST_PP_INC_222 223
#define BOOST_PP_INC_223 224
#define BOOST_PP_INC_224 225
#define BOOST_PP_INC_225 226
#define BOOST_PP_INC_226 227
#define BOOST_PP_INC_227 228
#define BOOST_PP_INC_228 229
#define BOOST_PP_INC_229 230
#define BOOST_PP_INC_230 231
#define BOOST_PP_INC_231 232
#define BOOST_PP_INC_232 233
#define BOOST_PP_INC_233 234
#define BOOST_PP_INC_234 235
#define BOOST_PP_INC_235 236
#define BOOST_PP_INC_236 237
#define BOOST_PP_INC_237 238
#define BOOST_PP_INC_238 239
#define BOOST_PP_INC_239 240
#define BOOST_PP_INC_240 241
#define BOOST_PP_INC_241 242
#define BOOST_PP_INC_242 243
#define BOOST_PP_INC_243 244
#define BOOST_PP_INC_244 245
#define BOOST_PP_INC_245 246
#define BOOST_PP_INC_246 247
#define BOOST_PP_INC_247 248
#define BOOST_PP_INC_248 249
#define BOOST_PP_INC_249 250
#define BOOST_PP_INC_250 251
#define BOOST_PP_INC_251 252
#define BOOST_PP_INC_252 253
#define BOOST_PP_INC_253 254
#define BOOST_PP_INC_254 255
#define BOOST_PP_INC_255 256
#define BOOST_PP_INC_256 256
# 16 "/usr/include/boost-1_41/boost/preprocessor/inc.hpp" 2
# 48 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/params.hpp" 2


#define BOOST_MPL_PP_AUX_PARAM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(param, BOOST_PP_INC(i))




#define BOOST_MPL_PP_PARAMS(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_PARAM_FUNC , param )
# 13 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/lambda.hpp" 1


#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/config/lambda.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/ttp.hpp" 1


#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED 
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/config/ttp.hpp"
#define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/config/lambda.hpp" 2
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/overload_resolution.hpp" 1


#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 2
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/integral_constant.hpp" 1






#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP 


# 1 "/usr/include/boost-1_41/boost/mpl/bool.hpp" 1


#define BOOST_MPL_BOOL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/bool.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/bool_fwd.hpp" 1


#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/bool_fwd.hpp"
namespace mpl_ {

template< bool C_ > struct bool_;


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

}

namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
# 18 "/usr/include/boost-1_41/boost/mpl/bool.hpp" 2



namespace mpl_ {

template< bool C_ > struct bool_
{
    static const bool value = C_;
    typedef integral_c_tag tag;
    typedef bool_ type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};


template< bool C_ >
bool const bool_<C_>::value;


}
# 11 "/usr/include/boost-1_41/boost/type_traits/integral_constant.hpp" 2


namespace boost{




template <class T, T val>

struct integral_constant : public mpl::integral_c<T, val>
{
   typedef integral_constant<T,val> type;
};

template<> struct integral_constant<bool,true> : public mpl::true_
{







   typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{







   typedef integral_constant<bool,false> type;
};

typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;

}
# 16 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_support.hpp" 1


#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_support.hpp"
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i,name,params) 
#define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) 
# 18 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/is_integral.hpp" 2

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-1_41/boost/type_traits/is_integral.hpp"
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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 77 "/usr/include/boost-1_41/boost/type_traits/is_integral.hpp" 2
# 14 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_float.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_float.hpp"
#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 14 "/usr/include/boost-1_41/boost/type_traits/is_float.hpp" 2

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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 26 "/usr/include/boost-1_41/boost/type_traits/is_float.hpp" 2
# 15 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/ice_or.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/detail/ice_or.hpp"
#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED 



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-1_41/boost/type_traits/is_arithmetic.hpp" 2




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 21 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp" 2

namespace boost {


namespace detail {

template< typename T >
struct is_arithmetic_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);




};

}






template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 50 "/usr/include/boost-1_41/boost/type_traits/is_arithmetic.hpp" 2
# 13 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_void.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_void.hpp"
#define BOOST_TT_IS_VOID_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/is_void.hpp" 2

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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 37 "/usr/include/boost-1_41/boost/type_traits/is_void.hpp" 2
# 14 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 18 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_fundamental_impl
    : ::boost::type_traits::ice_or<
          ::boost::is_arithmetic<T>::value
        , ::boost::is_void<T>::value
        >
{
};

}





template< typename T > struct is_fundamental : ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 44 "/usr/include/boost-1_41/boost/type_traits/is_fundamental.hpp" 2
# 23 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp"
#define BOOST_TT_IS_ENUM_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp"
#define BOOST_TT_INTRINSICS_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/config.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/config.hpp"
#define BOOST_TT_CONFIG_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/type_traits/config.hpp"
#define BOOST_TT_DECL 
# 45 "/usr/include/boost-1_41/boost/type_traits/config.hpp"
#define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
# 14 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp" 2
# 131 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/is_same.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_same.hpp"
#define BOOST_TT_IS_SAME_HPP_INCLUDED 
# 31 "/usr/include/boost-1_41/boost/type_traits/is_same.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 32 "/usr/include/boost-1_41/boost/type_traits/is_same.hpp" 2

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-1_41/boost/type_traits/is_same.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 101 "/usr/include/boost-1_41/boost/type_traits/is_same.hpp" 2
# 132 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_reference.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_reference.hpp"
#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED 
# 32 "/usr/include/boost-1_41/boost/type_traits/is_reference.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 33 "/usr/include/boost-1_41/boost/type_traits/is_reference.hpp" 2

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-1_41/boost/type_traits/is_reference.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 116 "/usr/include/boost-1_41/boost/type_traits/is_reference.hpp" 2
# 133 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp"
#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED 





# 1 "/usr/include/boost-1_41/boost/type_traits/detail/cv_traits_impl.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/detail/cv_traits_impl.hpp"
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/type_traits/detail/cv_traits_impl.hpp"
namespace boost {
namespace detail {







template <typename T> struct cv_traits_imp {};

template <typename T>
struct cv_traits_imp<T*>
{
    static const bool is_const = false;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const T*>
{
    static const bool is_const = true;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<volatile T*>
{
    static const bool is_const = false;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const volatile T*>
{
    static const bool is_const = true;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};
# 92 "/usr/include/boost-1_41/boost/type_traits/detail/cv_traits_impl.hpp"
}
}
# 29 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp" 2
# 40 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 41 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp" 2

namespace boost {
# 52 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp"
   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-1_41/boost/type_traits/is_volatile.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 132 "/usr/include/boost-1_41/boost/type_traits/is_volatile.hpp" 2
# 134 "/usr/include/boost-1_41/boost/type_traits/intrinsics.hpp" 2

#define BOOST_IS_UNION(T) __is_union(T)
#define BOOST_IS_POD(T) __is_pod(T)
#define BOOST_IS_EMPTY(T) __is_empty(T)
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
#define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
#define BOOST_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
#define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
#define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value)
#define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
#define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)

#define BOOST_IS_ABSTRACT(T) __is_abstract(T)
#define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
#define BOOST_IS_CLASS(T) __is_class(T)
#define BOOST_IS_ENUM(T) __is_enum(T)
#define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)




#define BOOST_ALIGNMENT_OF(T) __alignof__(T)


#define BOOST_HAS_TYPE_TRAITS_INTRINSICS 
# 15 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp" 2
# 32 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 33 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp" 2

namespace boost {
# 181 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp"
template< typename T > struct is_enum : ::boost::integral_constant<bool,__is_enum(T)> { };



}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 188 "/usr/include/boost-1_41/boost/type_traits/is_enum.hpp" 2
# 24 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp" 1
# 15 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp"
#define BOOST_TT_IS_ARRAY_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 25 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 28 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp" 2

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-1_41/boost/type_traits/is_array.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 90 "/usr/include/boost-1_41/boost/type_traits/is_array.hpp" 2
# 25 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp"
#define BOOST_TT_IS_CLASS_HPP_INCLUDED 
# 37 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 38 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp" 2

namespace boost {

namespace detail {
# 120 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp"
template <typename T>
struct is_class_impl
{
    static const bool value = __is_class(T);
};


}





template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 139 "/usr/include/boost-1_41/boost/type_traits/is_class.hpp" 2
# 26 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp"
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp"
#define BOOST_TT_REMOVE_CV_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/broken_compiler_spec.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/broken_compiler_spec.hpp"
#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED 
# 31 "/usr/include/boost-1_41/boost/type_traits/broken_compiler_spec.hpp"
#define BOOST_TT_BROKEN_COMPILER_SPEC(T) 
# 95 "/usr/include/boost-1_41/boost/type_traits/broken_compiler_spec.hpp"


















#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) BOOST_TT_BROKEN_COMPILER_SPEC(T)
# 15 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 27 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp" 2

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-1_41/boost/type_traits/remove_cv.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 60 "/usr/include/boost-1_41/boost/type_traits/remove_cv.hpp" 2
# 22 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 25 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp" 2

namespace boost {

namespace detail {
# 222 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp"
template <typename B, typename D>
struct is_base_and_derived_impl
{
    typedef typename remove_cv<B>::type ncvB;
    typedef typename remove_cv<D>::type ncvD;

    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};

}

template< typename Base, typename Derived > struct is_base_and_derived : ::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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 253 "/usr/include/boost-1_41/boost/type_traits/is_base_and_derived.hpp" 2
# 27 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/eval_if.hpp" 1


#define BOOST_MPL_EVAL_IF_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/eval_if.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/if.hpp" 1


#define BOOST_MPL_IF_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/if.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp" 1


#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/integral.hpp" 1


#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/eti.hpp" 1


#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp" 2
# 57 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp"
#define BOOST_MPL_AUX_VALUE_WKND(C) C
#define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C
# 67 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp"
#define BOOST_MPL_AUX_NESTED_VALUE_WKND(T,C) BOOST_MPL_AUX_VALUE_WKND(C)::value





namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/usr/include/boost-1_41/boost/mpl/aux_/value_wknd.hpp"
}}}
# 18 "/usr/include/boost-1_41/boost/mpl/if.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp" 1


#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/lambda_fwd.hpp" 1


#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/lambda_fwd.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/void_fwd.hpp" 1


#define BOOST_MPL_VOID_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/void_fwd.hpp"
namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/usr/include/boost-1_41/boost/mpl/lambda_fwd.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/na.hpp" 1


#define BOOST_MPL_AUX_NA_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/na.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/na_fwd.hpp" 1


#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/na_fwd.hpp"
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/na.hpp" 2



namespace boost { namespace mpl {

template< typename T >
struct is_na
    : false_
{



};

template<>
struct is_na<na>
    : true_
{



};

template< typename T >
struct is_not_na
    : true_
{



};

template<>
struct is_not_na<na>
    : false_
{



};


template< typename T, typename U > struct if_na
{
    typedef T type;
};

template< typename U > struct if_na<na,U>
{
    typedef U type;
};
# 93 "/usr/include/boost-1_41/boost/mpl/aux_/na.hpp"
}}
# 19 "/usr/include/boost-1_41/boost/mpl/lambda_fwd.hpp" 2





# 1 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_arity_param.hpp" 1


#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_arity_param.hpp"
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
# 25 "/usr/include/boost-1_41/boost/mpl/lambda_fwd.hpp" 2


namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/aux_/arity.hpp" 1


#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/arity.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/dtp.hpp" 1


#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/arity.hpp" 2
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp" 2




# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/enum.hpp" 1


#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED 
# 48 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/enum.hpp"
#define BOOST_MPL_PP_AUX_ENUM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) param



#define BOOST_MPL_PP_ENUM(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_ENUM_FUNC , param )
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1


#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/limits/arity.hpp" 1


#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/limits/arity.hpp"
#define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2




# 1 "/usr/include/boost-1_41/boost/preprocessor/logical/and.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/logical/and.hpp"
#define BOOST_PREPROCESSOR_LOGICAL_AND_HPP 



# 1 "/usr/include/boost-1_41/boost/preprocessor/logical/bitand.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/logical/bitand.hpp"
#define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP 






#define BOOST_PP_BITAND(x,y) BOOST_PP_BITAND_I(x, y)






#define BOOST_PP_BITAND_I(x,y) BOOST_PP_BITAND_ ## x ## y





#define BOOST_PP_BITAND_00 0
#define BOOST_PP_BITAND_01 0
#define BOOST_PP_BITAND_10 0
#define BOOST_PP_BITAND_11 1
# 20 "/usr/include/boost-1_41/boost/preprocessor/logical/and.hpp" 2




#define BOOST_PP_AND(p,q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q))
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/identity.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/identity.hpp"
#define BOOST_PREPROCESSOR_IDENTITY_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/facilities/identity.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/facilities/identity.hpp"
#define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 





#define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
# 16 "/usr/include/boost-1_41/boost/preprocessor/identity.hpp" 2
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/empty.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/empty.hpp"
#define BOOST_PREPROCESSOR_EMPTY_HPP 
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 66 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/add.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/add.hpp"
#define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/dec.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/dec.hpp"
#define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP 






#define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x)





#define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x

#define BOOST_PP_DEC_0 0
#define BOOST_PP_DEC_1 0
#define BOOST_PP_DEC_2 1
#define BOOST_PP_DEC_3 2
#define BOOST_PP_DEC_4 3
#define BOOST_PP_DEC_5 4
#define BOOST_PP_DEC_6 5
#define BOOST_PP_DEC_7 6
#define BOOST_PP_DEC_8 7
#define BOOST_PP_DEC_9 8
#define BOOST_PP_DEC_10 9
#define BOOST_PP_DEC_11 10
#define BOOST_PP_DEC_12 11
#define BOOST_PP_DEC_13 12
#define BOOST_PP_DEC_14 13
#define BOOST_PP_DEC_15 14
#define BOOST_PP_DEC_16 15
#define BOOST_PP_DEC_17 16
#define BOOST_PP_DEC_18 17
#define BOOST_PP_DEC_19 18
#define BOOST_PP_DEC_20 19
#define BOOST_PP_DEC_21 20
#define BOOST_PP_DEC_22 21
#define BOOST_PP_DEC_23 22
#define BOOST_PP_DEC_24 23
#define BOOST_PP_DEC_25 24
#define BOOST_PP_DEC_26 25
#define BOOST_PP_DEC_27 26
#define BOOST_PP_DEC_28 27
#define BOOST_PP_DEC_29 28
#define BOOST_PP_DEC_30 29
#define BOOST_PP_DEC_31 30
#define BOOST_PP_DEC_32 31
#define BOOST_PP_DEC_33 32
#define BOOST_PP_DEC_34 33
#define BOOST_PP_DEC_35 34
#define BOOST_PP_DEC_36 35
#define BOOST_PP_DEC_37 36
#define BOOST_PP_DEC_38 37
#define BOOST_PP_DEC_39 38
#define BOOST_PP_DEC_40 39
#define BOOST_PP_DEC_41 40
#define BOOST_PP_DEC_42 41
#define BOOST_PP_DEC_43 42
#define BOOST_PP_DEC_44 43
#define BOOST_PP_DEC_45 44
#define BOOST_PP_DEC_46 45
#define BOOST_PP_DEC_47 46
#define BOOST_PP_DEC_48 47
#define BOOST_PP_DEC_49 48
#define BOOST_PP_DEC_50 49
#define BOOST_PP_DEC_51 50
#define BOOST_PP_DEC_52 51
#define BOOST_PP_DEC_53 52
#define BOOST_PP_DEC_54 53
#define BOOST_PP_DEC_55 54
#define BOOST_PP_DEC_56 55
#define BOOST_PP_DEC_57 56
#define BOOST_PP_DEC_58 57
#define BOOST_PP_DEC_59 58
#define BOOST_PP_DEC_60 59
#define BOOST_PP_DEC_61 60
#define BOOST_PP_DEC_62 61
#define BOOST_PP_DEC_63 62
#define BOOST_PP_DEC_64 63
#define BOOST_PP_DEC_65 64
#define BOOST_PP_DEC_66 65
#define BOOST_PP_DEC_67 66
#define BOOST_PP_DEC_68 67
#define BOOST_PP_DEC_69 68
#define BOOST_PP_DEC_70 69
#define BOOST_PP_DEC_71 70
#define BOOST_PP_DEC_72 71
#define BOOST_PP_DEC_73 72
#define BOOST_PP_DEC_74 73
#define BOOST_PP_DEC_75 74
#define BOOST_PP_DEC_76 75
#define BOOST_PP_DEC_77 76
#define BOOST_PP_DEC_78 77
#define BOOST_PP_DEC_79 78
#define BOOST_PP_DEC_80 79
#define BOOST_PP_DEC_81 80
#define BOOST_PP_DEC_82 81
#define BOOST_PP_DEC_83 82
#define BOOST_PP_DEC_84 83
#define BOOST_PP_DEC_85 84
#define BOOST_PP_DEC_86 85
#define BOOST_PP_DEC_87 86
#define BOOST_PP_DEC_88 87
#define BOOST_PP_DEC_89 88
#define BOOST_PP_DEC_90 89
#define BOOST_PP_DEC_91 90
#define BOOST_PP_DEC_92 91
#define BOOST_PP_DEC_93 92
#define BOOST_PP_DEC_94 93
#define BOOST_PP_DEC_95 94
#define BOOST_PP_DEC_96 95
#define BOOST_PP_DEC_97 96
#define BOOST_PP_DEC_98 97
#define BOOST_PP_DEC_99 98
#define BOOST_PP_DEC_100 99
#define BOOST_PP_DEC_101 100
#define BOOST_PP_DEC_102 101
#define BOOST_PP_DEC_103 102
#define BOOST_PP_DEC_104 103
#define BOOST_PP_DEC_105 104
#define BOOST_PP_DEC_106 105
#define BOOST_PP_DEC_107 106
#define BOOST_PP_DEC_108 107
#define BOOST_PP_DEC_109 108
#define BOOST_PP_DEC_110 109
#define BOOST_PP_DEC_111 110
#define BOOST_PP_DEC_112 111
#define BOOST_PP_DEC_113 112
#define BOOST_PP_DEC_114 113
#define BOOST_PP_DEC_115 114
#define BOOST_PP_DEC_116 115
#define BOOST_PP_DEC_117 116
#define BOOST_PP_DEC_118 117
#define BOOST_PP_DEC_119 118
#define BOOST_PP_DEC_120 119
#define BOOST_PP_DEC_121 120
#define BOOST_PP_DEC_122 121
#define BOOST_PP_DEC_123 122
#define BOOST_PP_DEC_124 123
#define BOOST_PP_DEC_125 124
#define BOOST_PP_DEC_126 125
#define BOOST_PP_DEC_127 126
#define BOOST_PP_DEC_128 127
#define BOOST_PP_DEC_129 128
#define BOOST_PP_DEC_130 129
#define BOOST_PP_DEC_131 130
#define BOOST_PP_DEC_132 131
#define BOOST_PP_DEC_133 132
#define BOOST_PP_DEC_134 133
#define BOOST_PP_DEC_135 134
#define BOOST_PP_DEC_136 135
#define BOOST_PP_DEC_137 136
#define BOOST_PP_DEC_138 137
#define BOOST_PP_DEC_139 138
#define BOOST_PP_DEC_140 139
#define BOOST_PP_DEC_141 140
#define BOOST_PP_DEC_142 141
#define BOOST_PP_DEC_143 142
#define BOOST_PP_DEC_144 143
#define BOOST_PP_DEC_145 144
#define BOOST_PP_DEC_146 145
#define BOOST_PP_DEC_147 146
#define BOOST_PP_DEC_148 147
#define BOOST_PP_DEC_149 148
#define BOOST_PP_DEC_150 149
#define BOOST_PP_DEC_151 150
#define BOOST_PP_DEC_152 151
#define BOOST_PP_DEC_153 152
#define BOOST_PP_DEC_154 153
#define BOOST_PP_DEC_155 154
#define BOOST_PP_DEC_156 155
#define BOOST_PP_DEC_157 156
#define BOOST_PP_DEC_158 157
#define BOOST_PP_DEC_159 158
#define BOOST_PP_DEC_160 159
#define BOOST_PP_DEC_161 160
#define BOOST_PP_DEC_162 161
#define BOOST_PP_DEC_163 162
#define BOOST_PP_DEC_164 163
#define BOOST_PP_DEC_165 164
#define BOOST_PP_DEC_166 165
#define BOOST_PP_DEC_167 166
#define BOOST_PP_DEC_168 167
#define BOOST_PP_DEC_169 168
#define BOOST_PP_DEC_170 169
#define BOOST_PP_DEC_171 170
#define BOOST_PP_DEC_172 171
#define BOOST_PP_DEC_173 172
#define BOOST_PP_DEC_174 173
#define BOOST_PP_DEC_175 174
#define BOOST_PP_DEC_176 175
#define BOOST_PP_DEC_177 176
#define BOOST_PP_DEC_178 177
#define BOOST_PP_DEC_179 178
#define BOOST_PP_DEC_180 179
#define BOOST_PP_DEC_181 180
#define BOOST_PP_DEC_182 181
#define BOOST_PP_DEC_183 182
#define BOOST_PP_DEC_184 183
#define BOOST_PP_DEC_185 184
#define BOOST_PP_DEC_186 185
#define BOOST_PP_DEC_187 186
#define BOOST_PP_DEC_188 187
#define BOOST_PP_DEC_189 188
#define BOOST_PP_DEC_190 189
#define BOOST_PP_DEC_191 190
#define BOOST_PP_DEC_192 191
#define BOOST_PP_DEC_193 192
#define BOOST_PP_DEC_194 193
#define BOOST_PP_DEC_195 194
#define BOOST_PP_DEC_196 195
#define BOOST_PP_DEC_197 196
#define BOOST_PP_DEC_198 197
#define BOOST_PP_DEC_199 198
#define BOOST_PP_DEC_200 199
#define BOOST_PP_DEC_201 200
#define BOOST_PP_DEC_202 201
#define BOOST_PP_DEC_203 202
#define BOOST_PP_DEC_204 203
#define BOOST_PP_DEC_205 204
#define BOOST_PP_DEC_206 205
#define BOOST_PP_DEC_207 206
#define BOOST_PP_DEC_208 207
#define BOOST_PP_DEC_209 208
#define BOOST_PP_DEC_210 209
#define BOOST_PP_DEC_211 210
#define BOOST_PP_DEC_212 211
#define BOOST_PP_DEC_213 212
#define BOOST_PP_DEC_214 213
#define BOOST_PP_DEC_215 214
#define BOOST_PP_DEC_216 215
#define BOOST_PP_DEC_217 216
#define BOOST_PP_DEC_218 217
#define BOOST_PP_DEC_219 218
#define BOOST_PP_DEC_220 219
#define BOOST_PP_DEC_221 220
#define BOOST_PP_DEC_222 221
#define BOOST_PP_DEC_223 222
#define BOOST_PP_DEC_224 223
#define BOOST_PP_DEC_225 224
#define BOOST_PP_DEC_226 225
#define BOOST_PP_DEC_227 226
#define BOOST_PP_DEC_228 227
#define BOOST_PP_DEC_229 228
#define BOOST_PP_DEC_230 229
#define BOOST_PP_DEC_231 230
#define BOOST_PP_DEC_232 231
#define BOOST_PP_DEC_233 232
#define BOOST_PP_DEC_234 233
#define BOOST_PP_DEC_235 234
#define BOOST_PP_DEC_236 235
#define BOOST_PP_DEC_237 236
#define BOOST_PP_DEC_238 237
#define BOOST_PP_DEC_239 238
#define BOOST_PP_DEC_240 239
#define BOOST_PP_DEC_241 240
#define BOOST_PP_DEC_242 241
#define BOOST_PP_DEC_243 242
#define BOOST_PP_DEC_244 243
#define BOOST_PP_DEC_245 244
#define BOOST_PP_DEC_246 245
#define BOOST_PP_DEC_247 246
#define BOOST_PP_DEC_248 247
#define BOOST_PP_DEC_249 248
#define BOOST_PP_DEC_250 249
#define BOOST_PP_DEC_251 250
#define BOOST_PP_DEC_252 251
#define BOOST_PP_DEC_253 252
#define BOOST_PP_DEC_254 253
#define BOOST_PP_DEC_255 254
#define BOOST_PP_DEC_256 255
# 18 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/add.hpp" 2


# 1 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp"
#define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP 




# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/list/fold_left.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/fold_left.hpp"
#define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 1
# 19 "/usr/include/boost-1_41/boost/preprocessor/list/fold_left.hpp" 2

# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_41/boost/preprocessor/list/fold_left.hpp" 2







#define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))

#define BOOST_PP_LIST_FOLD_LEFT_257(o,s,l) BOOST_PP_ERROR(0x0004)

#define BOOST_PP_LIST_FOLD_LEFT_D(d,o,s,l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D






# 1 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_left.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_left.hpp"
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/control/expr_iif.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/control/expr_iif.hpp"
#define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP 






#define BOOST_PP_EXPR_IIF(bit,expr) BOOST_PP_EXPR_IIF_I(bit, expr)





#define BOOST_PP_EXPR_IIF_I(bit,expr) BOOST_PP_EXPR_IIF_ ## bit(expr)

#define BOOST_PP_EXPR_IIF_0(expr) 
#define BOOST_PP_EXPR_IIF_1(expr) expr
# 18 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_left.hpp" 2

# 1 "/usr/include/boost-1_41/boost/preprocessor/list/adt.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/adt.hpp"
#define BOOST_PREPROCESSOR_LIST_ADT_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/is_binary.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/detail/is_binary.hpp"
#define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/check.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/detail/check.hpp"
#define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP 







#define BOOST_PP_CHECK(x,type) BOOST_PP_CHECK_D(x, type)






#define BOOST_PP_CHECK_D(x,type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x))
#define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
#define BOOST_PP_CHECK_2(res,_) res
# 46 "/usr/include/boost-1_41/boost/preprocessor/detail/check.hpp"
#define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL
# 17 "/usr/include/boost-1_41/boost/preprocessor/detail/is_binary.hpp" 2




#define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)





#define BOOST_PP_IS_BINARY_CHECK(a,b) 1
#define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
# 19 "/usr/include/boost-1_41/boost/preprocessor/list/adt.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/logical/compl.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/logical/compl.hpp"
#define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP 






#define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x)






#define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x





#define BOOST_PP_COMPL_0 1
#define BOOST_PP_COMPL_1 0
# 20 "/usr/include/boost-1_41/boost/preprocessor/list/adt.hpp" 2




#define BOOST_PP_LIST_CONS(head,tail) (head, tail)



#define BOOST_PP_LIST_NIL BOOST_PP_NIL



#define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list)


#define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list




#define BOOST_PP_LIST_FIRST_I(head,tail) head



#define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list)


#define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list




#define BOOST_PP_LIST_REST_I(head,tail) tail
# 62 "/usr/include/boost-1_41/boost/preprocessor/list/adt.hpp"
#define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)





#define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list))
# 20 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_left.hpp" 2


#define BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
# 42 "/usr/include/boost-1_41/boost/preprocessor/list/fold_left.hpp" 2


#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1

#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) 0
# 22 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/list/fold_right.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/fold_right.hpp"
#define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP 




# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_41/boost/preprocessor/list/fold_right.hpp" 2





#define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))

#define BOOST_PP_LIST_FOLD_RIGHT_257(o,s,l) BOOST_PP_ERROR(0x0004)

#define BOOST_PP_LIST_FOLD_RIGHT_D(d,o,s,l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D




# 1 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_right.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_right.hpp"
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/list/reverse.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/reverse.hpp"
#define BOOST_PREPROCESSOR_LIST_REVERSE_HPP 







#define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)





#define BOOST_PP_LIST_REVERSE_O(d,s,x) (x, s)




#define BOOST_PP_LIST_REVERSE_D(d,list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
# 19 "/usr/include/boost-1_41/boost/preprocessor/list/detail/fold_right.hpp" 2

#define BOOST_PP_LIST_FOLD_RIGHT_1(o,s,l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l))
#define BOOST_PP_LIST_FOLD_RIGHT_2(o,s,l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l))
#define BOOST_PP_LIST_FOLD_RIGHT_3(o,s,l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l))
#define BOOST_PP_LIST_FOLD_RIGHT_4(o,s,l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l))
#define BOOST_PP_LIST_FOLD_RIGHT_5(o,s,l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l))
#define BOOST_PP_LIST_FOLD_RIGHT_6(o,s,l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l))
#define BOOST_PP_LIST_FOLD_RIGHT_7(o,s,l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l))
#define BOOST_PP_LIST_FOLD_RIGHT_8(o,s,l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l))
#define BOOST_PP_LIST_FOLD_RIGHT_9(o,s,l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l))
#define BOOST_PP_LIST_FOLD_RIGHT_10(o,s,l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l))
#define BOOST_PP_LIST_FOLD_RIGHT_11(o,s,l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l))
#define BOOST_PP_LIST_FOLD_RIGHT_12(o,s,l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l))
#define BOOST_PP_LIST_FOLD_RIGHT_13(o,s,l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l))
#define BOOST_PP_LIST_FOLD_RIGHT_14(o,s,l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l))
#define BOOST_PP_LIST_FOLD_RIGHT_15(o,s,l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l))
#define BOOST_PP_LIST_FOLD_RIGHT_16(o,s,l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l))
#define BOOST_PP_LIST_FOLD_RIGHT_17(o,s,l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l))
#define BOOST_PP_LIST_FOLD_RIGHT_18(o,s,l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l))
#define BOOST_PP_LIST_FOLD_RIGHT_19(o,s,l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l))
#define BOOST_PP_LIST_FOLD_RIGHT_20(o,s,l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l))
#define BOOST_PP_LIST_FOLD_RIGHT_21(o,s,l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l))
#define BOOST_PP_LIST_FOLD_RIGHT_22(o,s,l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l))
#define BOOST_PP_LIST_FOLD_RIGHT_23(o,s,l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l))
#define BOOST_PP_LIST_FOLD_RIGHT_24(o,s,l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l))
#define BOOST_PP_LIST_FOLD_RIGHT_25(o,s,l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l))
#define BOOST_PP_LIST_FOLD_RIGHT_26(o,s,l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l))
#define BOOST_PP_LIST_FOLD_RIGHT_27(o,s,l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l))
#define BOOST_PP_LIST_FOLD_RIGHT_28(o,s,l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l))
#define BOOST_PP_LIST_FOLD_RIGHT_29(o,s,l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l))
#define BOOST_PP_LIST_FOLD_RIGHT_30(o,s,l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l))
#define BOOST_PP_LIST_FOLD_RIGHT_31(o,s,l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l))
#define BOOST_PP_LIST_FOLD_RIGHT_32(o,s,l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l))
#define BOOST_PP_LIST_FOLD_RIGHT_33(o,s,l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l))
#define BOOST_PP_LIST_FOLD_RIGHT_34(o,s,l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l))
#define BOOST_PP_LIST_FOLD_RIGHT_35(o,s,l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l))
#define BOOST_PP_LIST_FOLD_RIGHT_36(o,s,l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l))
#define BOOST_PP_LIST_FOLD_RIGHT_37(o,s,l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l))
#define BOOST_PP_LIST_FOLD_RIGHT_38(o,s,l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l))
#define BOOST_PP_LIST_FOLD_RIGHT_39(o,s,l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l))
#define BOOST_PP_LIST_FOLD_RIGHT_40(o,s,l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l))
#define BOOST_PP_LIST_FOLD_RIGHT_41(o,s,l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l))
#define BOOST_PP_LIST_FOLD_RIGHT_42(o,s,l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l))
#define BOOST_PP_LIST_FOLD_RIGHT_43(o,s,l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l))
#define BOOST_PP_LIST_FOLD_RIGHT_44(o,s,l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l))
#define BOOST_PP_LIST_FOLD_RIGHT_45(o,s,l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l))
#define BOOST_PP_LIST_FOLD_RIGHT_46(o,s,l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l))
#define BOOST_PP_LIST_FOLD_RIGHT_47(o,s,l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l))
#define BOOST_PP_LIST_FOLD_RIGHT_48(o,s,l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l))
#define BOOST_PP_LIST_FOLD_RIGHT_49(o,s,l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l))
#define BOOST_PP_LIST_FOLD_RIGHT_50(o,s,l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l))
#define BOOST_PP_LIST_FOLD_RIGHT_51(o,s,l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l))
#define BOOST_PP_LIST_FOLD_RIGHT_52(o,s,l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l))
#define BOOST_PP_LIST_FOLD_RIGHT_53(o,s,l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l))
#define BOOST_PP_LIST_FOLD_RIGHT_54(o,s,l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l))
#define BOOST_PP_LIST_FOLD_RIGHT_55(o,s,l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l))
#define BOOST_PP_LIST_FOLD_RIGHT_56(o,s,l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l))
#define BOOST_PP_LIST_FOLD_RIGHT_57(o,s,l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l))
#define BOOST_PP_LIST_FOLD_RIGHT_58(o,s,l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l))
#define BOOST_PP_LIST_FOLD_RIGHT_59(o,s,l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l))
#define BOOST_PP_LIST_FOLD_RIGHT_60(o,s,l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l))
#define BOOST_PP_LIST_FOLD_RIGHT_61(o,s,l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l))
#define BOOST_PP_LIST_FOLD_RIGHT_62(o,s,l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l))
#define BOOST_PP_LIST_FOLD_RIGHT_63(o,s,l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l))
#define BOOST_PP_LIST_FOLD_RIGHT_64(o,s,l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l))
#define BOOST_PP_LIST_FOLD_RIGHT_65(o,s,l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l))
#define BOOST_PP_LIST_FOLD_RIGHT_66(o,s,l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l))
#define BOOST_PP_LIST_FOLD_RIGHT_67(o,s,l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l))
#define BOOST_PP_LIST_FOLD_RIGHT_68(o,s,l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l))
#define BOOST_PP_LIST_FOLD_RIGHT_69(o,s,l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l))
#define BOOST_PP_LIST_FOLD_RIGHT_70(o,s,l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l))
#define BOOST_PP_LIST_FOLD_RIGHT_71(o,s,l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l))
#define BOOST_PP_LIST_FOLD_RIGHT_72(o,s,l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l))
#define BOOST_PP_LIST_FOLD_RIGHT_73(o,s,l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l))
#define BOOST_PP_LIST_FOLD_RIGHT_74(o,s,l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l))
#define BOOST_PP_LIST_FOLD_RIGHT_75(o,s,l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l))
#define BOOST_PP_LIST_FOLD_RIGHT_76(o,s,l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l))
#define BOOST_PP_LIST_FOLD_RIGHT_77(o,s,l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l))
#define BOOST_PP_LIST_FOLD_RIGHT_78(o,s,l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l))
#define BOOST_PP_LIST_FOLD_RIGHT_79(o,s,l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l))
#define BOOST_PP_LIST_FOLD_RIGHT_80(o,s,l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l))
#define BOOST_PP_LIST_FOLD_RIGHT_81(o,s,l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l))
#define BOOST_PP_LIST_FOLD_RIGHT_82(o,s,l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l))
#define BOOST_PP_LIST_FOLD_RIGHT_83(o,s,l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l))
#define BOOST_PP_LIST_FOLD_RIGHT_84(o,s,l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l))
#define BOOST_PP_LIST_FOLD_RIGHT_85(o,s,l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l))
#define BOOST_PP_LIST_FOLD_RIGHT_86(o,s,l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l))
#define BOOST_PP_LIST_FOLD_RIGHT_87(o,s,l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l))
#define BOOST_PP_LIST_FOLD_RIGHT_88(o,s,l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l))
#define BOOST_PP_LIST_FOLD_RIGHT_89(o,s,l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l))
#define BOOST_PP_LIST_FOLD_RIGHT_90(o,s,l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l))
#define BOOST_PP_LIST_FOLD_RIGHT_91(o,s,l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l))
#define BOOST_PP_LIST_FOLD_RIGHT_92(o,s,l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l))
#define BOOST_PP_LIST_FOLD_RIGHT_93(o,s,l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l))
#define BOOST_PP_LIST_FOLD_RIGHT_94(o,s,l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l))
#define BOOST_PP_LIST_FOLD_RIGHT_95(o,s,l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l))
#define BOOST_PP_LIST_FOLD_RIGHT_96(o,s,l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l))
#define BOOST_PP_LIST_FOLD_RIGHT_97(o,s,l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l))
#define BOOST_PP_LIST_FOLD_RIGHT_98(o,s,l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l))
#define BOOST_PP_LIST_FOLD_RIGHT_99(o,s,l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l))
#define BOOST_PP_LIST_FOLD_RIGHT_100(o,s,l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l))
#define BOOST_PP_LIST_FOLD_RIGHT_101(o,s,l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l))
#define BOOST_PP_LIST_FOLD_RIGHT_102(o,s,l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l))
#define BOOST_PP_LIST_FOLD_RIGHT_103(o,s,l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l))
#define BOOST_PP_LIST_FOLD_RIGHT_104(o,s,l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l))
#define BOOST_PP_LIST_FOLD_RIGHT_105(o,s,l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l))
#define BOOST_PP_LIST_FOLD_RIGHT_106(o,s,l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l))
#define BOOST_PP_LIST_FOLD_RIGHT_107(o,s,l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l))
#define BOOST_PP_LIST_FOLD_RIGHT_108(o,s,l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l))
#define BOOST_PP_LIST_FOLD_RIGHT_109(o,s,l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l))
#define BOOST_PP_LIST_FOLD_RIGHT_110(o,s,l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l))
#define BOOST_PP_LIST_FOLD_RIGHT_111(o,s,l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l))
#define BOOST_PP_LIST_FOLD_RIGHT_112(o,s,l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l))
#define BOOST_PP_LIST_FOLD_RIGHT_113(o,s,l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l))
#define BOOST_PP_LIST_FOLD_RIGHT_114(o,s,l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l))
#define BOOST_PP_LIST_FOLD_RIGHT_115(o,s,l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l))
#define BOOST_PP_LIST_FOLD_RIGHT_116(o,s,l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l))
#define BOOST_PP_LIST_FOLD_RIGHT_117(o,s,l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l))
#define BOOST_PP_LIST_FOLD_RIGHT_118(o,s,l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l))
#define BOOST_PP_LIST_FOLD_RIGHT_119(o,s,l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l))
#define BOOST_PP_LIST_FOLD_RIGHT_120(o,s,l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l))
#define BOOST_PP_LIST_FOLD_RIGHT_121(o,s,l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l))
#define BOOST_PP_LIST_FOLD_RIGHT_122(o,s,l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l))
#define BOOST_PP_LIST_FOLD_RIGHT_123(o,s,l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l))
#define BOOST_PP_LIST_FOLD_RIGHT_124(o,s,l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l))
#define BOOST_PP_LIST_FOLD_RIGHT_125(o,s,l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l))
#define BOOST_PP_LIST_FOLD_RIGHT_126(o,s,l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l))
#define BOOST_PP_LIST_FOLD_RIGHT_127(o,s,l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l))
#define BOOST_PP_LIST_FOLD_RIGHT_128(o,s,l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l))
#define BOOST_PP_LIST_FOLD_RIGHT_129(o,s,l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l))
#define BOOST_PP_LIST_FOLD_RIGHT_130(o,s,l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l))
#define BOOST_PP_LIST_FOLD_RIGHT_131(o,s,l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l))
#define BOOST_PP_LIST_FOLD_RIGHT_132(o,s,l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l))
#define BOOST_PP_LIST_FOLD_RIGHT_133(o,s,l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l))
#define BOOST_PP_LIST_FOLD_RIGHT_134(o,s,l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l))
#define BOOST_PP_LIST_FOLD_RIGHT_135(o,s,l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l))
#define BOOST_PP_LIST_FOLD_RIGHT_136(o,s,l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l))
#define BOOST_PP_LIST_FOLD_RIGHT_137(o,s,l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l))
#define BOOST_PP_LIST_FOLD_RIGHT_138(o,s,l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l))
#define BOOST_PP_LIST_FOLD_RIGHT_139(o,s,l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l))
#define BOOST_PP_LIST_FOLD_RIGHT_140(o,s,l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l))
#define BOOST_PP_LIST_FOLD_RIGHT_141(o,s,l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l))
#define BOOST_PP_LIST_FOLD_RIGHT_142(o,s,l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l))
#define BOOST_PP_LIST_FOLD_RIGHT_143(o,s,l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l))
#define BOOST_PP_LIST_FOLD_RIGHT_144(o,s,l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l))
#define BOOST_PP_LIST_FOLD_RIGHT_145(o,s,l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l))
#define BOOST_PP_LIST_FOLD_RIGHT_146(o,s,l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l))
#define BOOST_PP_LIST_FOLD_RIGHT_147(o,s,l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l))
#define BOOST_PP_LIST_FOLD_RIGHT_148(o,s,l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l))
#define BOOST_PP_LIST_FOLD_RIGHT_149(o,s,l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l))
#define BOOST_PP_LIST_FOLD_RIGHT_150(o,s,l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l))
#define BOOST_PP_LIST_FOLD_RIGHT_151(o,s,l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l))
#define BOOST_PP_LIST_FOLD_RIGHT_152(o,s,l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l))
#define BOOST_PP_LIST_FOLD_RIGHT_153(o,s,l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l))
#define BOOST_PP_LIST_FOLD_RIGHT_154(o,s,l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l))
#define BOOST_PP_LIST_FOLD_RIGHT_155(o,s,l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l))
#define BOOST_PP_LIST_FOLD_RIGHT_156(o,s,l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l))
#define BOOST_PP_LIST_FOLD_RIGHT_157(o,s,l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l))
#define BOOST_PP_LIST_FOLD_RIGHT_158(o,s,l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l))
#define BOOST_PP_LIST_FOLD_RIGHT_159(o,s,l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l))
#define BOOST_PP_LIST_FOLD_RIGHT_160(o,s,l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l))
#define BOOST_PP_LIST_FOLD_RIGHT_161(o,s,l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l))
#define BOOST_PP_LIST_FOLD_RIGHT_162(o,s,l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l))
#define BOOST_PP_LIST_FOLD_RIGHT_163(o,s,l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l))
#define BOOST_PP_LIST_FOLD_RIGHT_164(o,s,l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l))
#define BOOST_PP_LIST_FOLD_RIGHT_165(o,s,l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l))
#define BOOST_PP_LIST_FOLD_RIGHT_166(o,s,l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l))
#define BOOST_PP_LIST_FOLD_RIGHT_167(o,s,l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l))
#define BOOST_PP_LIST_FOLD_RIGHT_168(o,s,l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l))
#define BOOST_PP_LIST_FOLD_RIGHT_169(o,s,l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l))
#define BOOST_PP_LIST_FOLD_RIGHT_170(o,s,l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l))
#define BOOST_PP_LIST_FOLD_RIGHT_171(o,s,l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l))
#define BOOST_PP_LIST_FOLD_RIGHT_172(o,s,l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l))
#define BOOST_PP_LIST_FOLD_RIGHT_173(o,s,l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l))
#define BOOST_PP_LIST_FOLD_RIGHT_174(o,s,l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l))
#define BOOST_PP_LIST_FOLD_RIGHT_175(o,s,l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l))
#define BOOST_PP_LIST_FOLD_RIGHT_176(o,s,l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l))
#define BOOST_PP_LIST_FOLD_RIGHT_177(o,s,l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l))
#define BOOST_PP_LIST_FOLD_RIGHT_178(o,s,l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l))
#define BOOST_PP_LIST_FOLD_RIGHT_179(o,s,l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l))
#define BOOST_PP_LIST_FOLD_RIGHT_180(o,s,l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l))
#define BOOST_PP_LIST_FOLD_RIGHT_181(o,s,l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l))
#define BOOST_PP_LIST_FOLD_RIGHT_182(o,s,l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l))
#define BOOST_PP_LIST_FOLD_RIGHT_183(o,s,l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l))
#define BOOST_PP_LIST_FOLD_RIGHT_184(o,s,l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l))
#define BOOST_PP_LIST_FOLD_RIGHT_185(o,s,l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l))
#define BOOST_PP_LIST_FOLD_RIGHT_186(o,s,l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l))
#define BOOST_PP_LIST_FOLD_RIGHT_187(o,s,l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l))
#define BOOST_PP_LIST_FOLD_RIGHT_188(o,s,l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l))
#define BOOST_PP_LIST_FOLD_RIGHT_189(o,s,l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l))
#define BOOST_PP_LIST_FOLD_RIGHT_190(o,s,l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l))
#define BOOST_PP_LIST_FOLD_RIGHT_191(o,s,l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l))
#define BOOST_PP_LIST_FOLD_RIGHT_192(o,s,l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l))
#define BOOST_PP_LIST_FOLD_RIGHT_193(o,s,l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l))
#define BOOST_PP_LIST_FOLD_RIGHT_194(o,s,l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l))
#define BOOST_PP_LIST_FOLD_RIGHT_195(o,s,l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l))
#define BOOST_PP_LIST_FOLD_RIGHT_196(o,s,l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l))
#define BOOST_PP_LIST_FOLD_RIGHT_197(o,s,l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l))
#define BOOST_PP_LIST_FOLD_RIGHT_198(o,s,l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l))
#define BOOST_PP_LIST_FOLD_RIGHT_199(o,s,l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l))
#define BOOST_PP_LIST_FOLD_RIGHT_200(o,s,l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l))
#define BOOST_PP_LIST_FOLD_RIGHT_201(o,s,l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l))
#define BOOST_PP_LIST_FOLD_RIGHT_202(o,s,l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l))
#define BOOST_PP_LIST_FOLD_RIGHT_203(o,s,l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l))
#define BOOST_PP_LIST_FOLD_RIGHT_204(o,s,l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l))
#define BOOST_PP_LIST_FOLD_RIGHT_205(o,s,l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l))
#define BOOST_PP_LIST_FOLD_RIGHT_206(o,s,l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l))
#define BOOST_PP_LIST_FOLD_RIGHT_207(o,s,l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l))
#define BOOST_PP_LIST_FOLD_RIGHT_208(o,s,l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l))
#define BOOST_PP_LIST_FOLD_RIGHT_209(o,s,l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l))
#define BOOST_PP_LIST_FOLD_RIGHT_210(o,s,l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l))
#define BOOST_PP_LIST_FOLD_RIGHT_211(o,s,l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l))
#define BOOST_PP_LIST_FOLD_RIGHT_212(o,s,l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l))
#define BOOST_PP_LIST_FOLD_RIGHT_213(o,s,l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l))
#define BOOST_PP_LIST_FOLD_RIGHT_214(o,s,l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l))
#define BOOST_PP_LIST_FOLD_RIGHT_215(o,s,l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l))
#define BOOST_PP_LIST_FOLD_RIGHT_216(o,s,l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l))
#define BOOST_PP_LIST_FOLD_RIGHT_217(o,s,l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l))
#define BOOST_PP_LIST_FOLD_RIGHT_218(o,s,l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l))
#define BOOST_PP_LIST_FOLD_RIGHT_219(o,s,l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l))
#define BOOST_PP_LIST_FOLD_RIGHT_220(o,s,l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l))
#define BOOST_PP_LIST_FOLD_RIGHT_221(o,s,l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l))
#define BOOST_PP_LIST_FOLD_RIGHT_222(o,s,l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l))
#define BOOST_PP_LIST_FOLD_RIGHT_223(o,s,l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l))
#define BOOST_PP_LIST_FOLD_RIGHT_224(o,s,l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l))
#define BOOST_PP_LIST_FOLD_RIGHT_225(o,s,l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l))
#define BOOST_PP_LIST_FOLD_RIGHT_226(o,s,l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l))
#define BOOST_PP_LIST_FOLD_RIGHT_227(o,s,l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l))
#define BOOST_PP_LIST_FOLD_RIGHT_228(o,s,l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l))
#define BOOST_PP_LIST_FOLD_RIGHT_229(o,s,l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l))
#define BOOST_PP_LIST_FOLD_RIGHT_230(o,s,l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l))
#define BOOST_PP_LIST_FOLD_RIGHT_231(o,s,l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l))
#define BOOST_PP_LIST_FOLD_RIGHT_232(o,s,l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l))
#define BOOST_PP_LIST_FOLD_RIGHT_233(o,s,l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l))
#define BOOST_PP_LIST_FOLD_RIGHT_234(o,s,l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l))
#define BOOST_PP_LIST_FOLD_RIGHT_235(o,s,l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l))
#define BOOST_PP_LIST_FOLD_RIGHT_236(o,s,l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l))
#define BOOST_PP_LIST_FOLD_RIGHT_237(o,s,l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l))
#define BOOST_PP_LIST_FOLD_RIGHT_238(o,s,l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l))
#define BOOST_PP_LIST_FOLD_RIGHT_239(o,s,l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l))
#define BOOST_PP_LIST_FOLD_RIGHT_240(o,s,l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l))
#define BOOST_PP_LIST_FOLD_RIGHT_241(o,s,l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l))
#define BOOST_PP_LIST_FOLD_RIGHT_242(o,s,l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l))
#define BOOST_PP_LIST_FOLD_RIGHT_243(o,s,l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l))
#define BOOST_PP_LIST_FOLD_RIGHT_244(o,s,l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l))
#define BOOST_PP_LIST_FOLD_RIGHT_245(o,s,l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l))
#define BOOST_PP_LIST_FOLD_RIGHT_246(o,s,l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l))
#define BOOST_PP_LIST_FOLD_RIGHT_247(o,s,l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l))
#define BOOST_PP_LIST_FOLD_RIGHT_248(o,s,l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l))
#define BOOST_PP_LIST_FOLD_RIGHT_249(o,s,l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l))
#define BOOST_PP_LIST_FOLD_RIGHT_250(o,s,l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l))
#define BOOST_PP_LIST_FOLD_RIGHT_251(o,s,l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l))
#define BOOST_PP_LIST_FOLD_RIGHT_252(o,s,l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l))
#define BOOST_PP_LIST_FOLD_RIGHT_253(o,s,l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l))
#define BOOST_PP_LIST_FOLD_RIGHT_254(o,s,l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l))
#define BOOST_PP_LIST_FOLD_RIGHT_255(o,s,l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l))
#define BOOST_PP_LIST_FOLD_RIGHT_256(o,s,l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l))
# 38 "/usr/include/boost-1_41/boost/preprocessor/list/fold_right.hpp" 2
# 23 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 2
# 31 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp"
#define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))




#define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))


#define BOOST_PP_WHILE_F(d,_) 0
# 48 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/control/detail/while.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/control/detail/while.hpp"
#define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP 





#define BOOST_PP_WHILE_1(p,o,s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
#define BOOST_PP_WHILE_2(p,o,s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
#define BOOST_PP_WHILE_3(p,o,s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
#define BOOST_PP_WHILE_4(p,o,s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
#define BOOST_PP_WHILE_5(p,o,s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s)
#define BOOST_PP_WHILE_6(p,o,s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s)
#define BOOST_PP_WHILE_7(p,o,s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s)
#define BOOST_PP_WHILE_8(p,o,s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s)
#define BOOST_PP_WHILE_9(p,o,s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s)
#define BOOST_PP_WHILE_10(p,o,s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s)
#define BOOST_PP_WHILE_11(p,o,s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s)
#define BOOST_PP_WHILE_12(p,o,s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s)
#define BOOST_PP_WHILE_13(p,o,s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s)
#define BOOST_PP_WHILE_14(p,o,s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s)
#define BOOST_PP_WHILE_15(p,o,s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s)
#define BOOST_PP_WHILE_16(p,o,s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s)
#define BOOST_PP_WHILE_17(p,o,s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s)
#define BOOST_PP_WHILE_18(p,o,s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s)
#define BOOST_PP_WHILE_19(p,o,s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s)
#define BOOST_PP_WHILE_20(p,o,s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s)
#define BOOST_PP_WHILE_21(p,o,s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s)
#define BOOST_PP_WHILE_22(p,o,s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s)
#define BOOST_PP_WHILE_23(p,o,s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s)
#define BOOST_PP_WHILE_24(p,o,s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s)
#define BOOST_PP_WHILE_25(p,o,s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s)
#define BOOST_PP_WHILE_26(p,o,s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s)
#define BOOST_PP_WHILE_27(p,o,s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s)
#define BOOST_PP_WHILE_28(p,o,s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s)
#define BOOST_PP_WHILE_29(p,o,s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s)
#define BOOST_PP_WHILE_30(p,o,s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s)
#define BOOST_PP_WHILE_31(p,o,s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s)
#define BOOST_PP_WHILE_32(p,o,s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s)
#define BOOST_PP_WHILE_33(p,o,s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s)
#define BOOST_PP_WHILE_34(p,o,s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s)
#define BOOST_PP_WHILE_35(p,o,s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s)
#define BOOST_PP_WHILE_36(p,o,s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s)
#define BOOST_PP_WHILE_37(p,o,s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s)
#define BOOST_PP_WHILE_38(p,o,s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s)
#define BOOST_PP_WHILE_39(p,o,s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s)
#define BOOST_PP_WHILE_40(p,o,s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s)
#define BOOST_PP_WHILE_41(p,o,s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s)
#define BOOST_PP_WHILE_42(p,o,s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s)
#define BOOST_PP_WHILE_43(p,o,s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s)
#define BOOST_PP_WHILE_44(p,o,s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s)
#define BOOST_PP_WHILE_45(p,o,s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s)
#define BOOST_PP_WHILE_46(p,o,s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s)
#define BOOST_PP_WHILE_47(p,o,s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s)
#define BOOST_PP_WHILE_48(p,o,s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s)
#define BOOST_PP_WHILE_49(p,o,s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s)
#define BOOST_PP_WHILE_50(p,o,s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s)
#define BOOST_PP_WHILE_51(p,o,s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s)
#define BOOST_PP_WHILE_52(p,o,s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s)
#define BOOST_PP_WHILE_53(p,o,s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s)
#define BOOST_PP_WHILE_54(p,o,s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s)
#define BOOST_PP_WHILE_55(p,o,s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s)
#define BOOST_PP_WHILE_56(p,o,s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s)
#define BOOST_PP_WHILE_57(p,o,s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s)
#define BOOST_PP_WHILE_58(p,o,s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s)
#define BOOST_PP_WHILE_59(p,o,s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s)
#define BOOST_PP_WHILE_60(p,o,s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s)
#define BOOST_PP_WHILE_61(p,o,s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s)
#define BOOST_PP_WHILE_62(p,o,s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s)
#define BOOST_PP_WHILE_63(p,o,s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s)
#define BOOST_PP_WHILE_64(p,o,s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s)
#define BOOST_PP_WHILE_65(p,o,s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s)
#define BOOST_PP_WHILE_66(p,o,s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s)
#define BOOST_PP_WHILE_67(p,o,s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s)
#define BOOST_PP_WHILE_68(p,o,s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s)
#define BOOST_PP_WHILE_69(p,o,s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s)
#define BOOST_PP_WHILE_70(p,o,s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s)
#define BOOST_PP_WHILE_71(p,o,s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s)
#define BOOST_PP_WHILE_72(p,o,s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s)
#define BOOST_PP_WHILE_73(p,o,s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s)
#define BOOST_PP_WHILE_74(p,o,s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s)
#define BOOST_PP_WHILE_75(p,o,s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s)
#define BOOST_PP_WHILE_76(p,o,s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s)
#define BOOST_PP_WHILE_77(p,o,s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s)
#define BOOST_PP_WHILE_78(p,o,s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s)
#define BOOST_PP_WHILE_79(p,o,s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s)
#define BOOST_PP_WHILE_80(p,o,s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s)
#define BOOST_PP_WHILE_81(p,o,s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s)
#define BOOST_PP_WHILE_82(p,o,s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s)
#define BOOST_PP_WHILE_83(p,o,s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s)
#define BOOST_PP_WHILE_84(p,o,s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s)
#define BOOST_PP_WHILE_85(p,o,s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s)
#define BOOST_PP_WHILE_86(p,o,s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s)
#define BOOST_PP_WHILE_87(p,o,s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s)
#define BOOST_PP_WHILE_88(p,o,s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s)
#define BOOST_PP_WHILE_89(p,o,s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s)
#define BOOST_PP_WHILE_90(p,o,s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s)
#define BOOST_PP_WHILE_91(p,o,s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s)
#define BOOST_PP_WHILE_92(p,o,s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s)
#define BOOST_PP_WHILE_93(p,o,s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s)
#define BOOST_PP_WHILE_94(p,o,s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s)
#define BOOST_PP_WHILE_95(p,o,s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s)
#define BOOST_PP_WHILE_96(p,o,s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s)
#define BOOST_PP_WHILE_97(p,o,s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s)
#define BOOST_PP_WHILE_98(p,o,s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s)
#define BOOST_PP_WHILE_99(p,o,s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s)
#define BOOST_PP_WHILE_100(p,o,s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s)
#define BOOST_PP_WHILE_101(p,o,s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s)
#define BOOST_PP_WHILE_102(p,o,s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s)
#define BOOST_PP_WHILE_103(p,o,s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s)
#define BOOST_PP_WHILE_104(p,o,s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s)
#define BOOST_PP_WHILE_105(p,o,s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s)
#define BOOST_PP_WHILE_106(p,o,s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s)
#define BOOST_PP_WHILE_107(p,o,s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s)
#define BOOST_PP_WHILE_108(p,o,s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s)
#define BOOST_PP_WHILE_109(p,o,s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s)
#define BOOST_PP_WHILE_110(p,o,s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s)
#define BOOST_PP_WHILE_111(p,o,s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s)
#define BOOST_PP_WHILE_112(p,o,s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s)
#define BOOST_PP_WHILE_113(p,o,s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s)
#define BOOST_PP_WHILE_114(p,o,s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s)
#define BOOST_PP_WHILE_115(p,o,s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s)
#define BOOST_PP_WHILE_116(p,o,s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s)
#define BOOST_PP_WHILE_117(p,o,s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s)
#define BOOST_PP_WHILE_118(p,o,s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s)
#define BOOST_PP_WHILE_119(p,o,s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s)
#define BOOST_PP_WHILE_120(p,o,s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s)
#define BOOST_PP_WHILE_121(p,o,s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s)
#define BOOST_PP_WHILE_122(p,o,s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s)
#define BOOST_PP_WHILE_123(p,o,s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s)
#define BOOST_PP_WHILE_124(p,o,s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s)
#define BOOST_PP_WHILE_125(p,o,s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s)
#define BOOST_PP_WHILE_126(p,o,s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s)
#define BOOST_PP_WHILE_127(p,o,s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s)
#define BOOST_PP_WHILE_128(p,o,s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s)
#define BOOST_PP_WHILE_129(p,o,s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s)
#define BOOST_PP_WHILE_130(p,o,s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s)
#define BOOST_PP_WHILE_131(p,o,s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s)
#define BOOST_PP_WHILE_132(p,o,s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s)
#define BOOST_PP_WHILE_133(p,o,s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s)
#define BOOST_PP_WHILE_134(p,o,s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s)
#define BOOST_PP_WHILE_135(p,o,s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s)
#define BOOST_PP_WHILE_136(p,o,s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s)
#define BOOST_PP_WHILE_137(p,o,s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s)
#define BOOST_PP_WHILE_138(p,o,s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s)
#define BOOST_PP_WHILE_139(p,o,s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s)
#define BOOST_PP_WHILE_140(p,o,s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s)
#define BOOST_PP_WHILE_141(p,o,s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s)
#define BOOST_PP_WHILE_142(p,o,s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s)
#define BOOST_PP_WHILE_143(p,o,s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s)
#define BOOST_PP_WHILE_144(p,o,s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s)
#define BOOST_PP_WHILE_145(p,o,s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s)
#define BOOST_PP_WHILE_146(p,o,s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s)
#define BOOST_PP_WHILE_147(p,o,s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s)
#define BOOST_PP_WHILE_148(p,o,s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s)
#define BOOST_PP_WHILE_149(p,o,s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s)
#define BOOST_PP_WHILE_150(p,o,s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s)
#define BOOST_PP_WHILE_151(p,o,s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s)
#define BOOST_PP_WHILE_152(p,o,s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s)
#define BOOST_PP_WHILE_153(p,o,s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s)
#define BOOST_PP_WHILE_154(p,o,s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s)
#define BOOST_PP_WHILE_155(p,o,s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s)
#define BOOST_PP_WHILE_156(p,o,s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s)
#define BOOST_PP_WHILE_157(p,o,s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s)
#define BOOST_PP_WHILE_158(p,o,s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s)
#define BOOST_PP_WHILE_159(p,o,s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s)
#define BOOST_PP_WHILE_160(p,o,s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s)
#define BOOST_PP_WHILE_161(p,o,s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s)
#define BOOST_PP_WHILE_162(p,o,s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s)
#define BOOST_PP_WHILE_163(p,o,s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s)
#define BOOST_PP_WHILE_164(p,o,s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s)
#define BOOST_PP_WHILE_165(p,o,s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s)
#define BOOST_PP_WHILE_166(p,o,s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s)
#define BOOST_PP_WHILE_167(p,o,s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s)
#define BOOST_PP_WHILE_168(p,o,s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s)
#define BOOST_PP_WHILE_169(p,o,s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s)
#define BOOST_PP_WHILE_170(p,o,s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s)
#define BOOST_PP_WHILE_171(p,o,s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s)
#define BOOST_PP_WHILE_172(p,o,s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s)
#define BOOST_PP_WHILE_173(p,o,s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s)
#define BOOST_PP_WHILE_174(p,o,s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s)
#define BOOST_PP_WHILE_175(p,o,s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s)
#define BOOST_PP_WHILE_176(p,o,s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s)
#define BOOST_PP_WHILE_177(p,o,s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s)
#define BOOST_PP_WHILE_178(p,o,s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s)
#define BOOST_PP_WHILE_179(p,o,s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s)
#define BOOST_PP_WHILE_180(p,o,s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s)
#define BOOST_PP_WHILE_181(p,o,s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s)
#define BOOST_PP_WHILE_182(p,o,s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s)
#define BOOST_PP_WHILE_183(p,o,s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s)
#define BOOST_PP_WHILE_184(p,o,s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s)
#define BOOST_PP_WHILE_185(p,o,s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s)
#define BOOST_PP_WHILE_186(p,o,s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s)
#define BOOST_PP_WHILE_187(p,o,s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s)
#define BOOST_PP_WHILE_188(p,o,s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s)
#define BOOST_PP_WHILE_189(p,o,s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s)
#define BOOST_PP_WHILE_190(p,o,s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s)
#define BOOST_PP_WHILE_191(p,o,s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s)
#define BOOST_PP_WHILE_192(p,o,s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s)
#define BOOST_PP_WHILE_193(p,o,s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s)
#define BOOST_PP_WHILE_194(p,o,s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s)
#define BOOST_PP_WHILE_195(p,o,s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s)
#define BOOST_PP_WHILE_196(p,o,s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s)
#define BOOST_PP_WHILE_197(p,o,s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s)
#define BOOST_PP_WHILE_198(p,o,s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s)
#define BOOST_PP_WHILE_199(p,o,s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s)
#define BOOST_PP_WHILE_200(p,o,s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s)
#define BOOST_PP_WHILE_201(p,o,s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s)
#define BOOST_PP_WHILE_202(p,o,s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s)
#define BOOST_PP_WHILE_203(p,o,s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s)
#define BOOST_PP_WHILE_204(p,o,s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s)
#define BOOST_PP_WHILE_205(p,o,s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s)
#define BOOST_PP_WHILE_206(p,o,s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s)
#define BOOST_PP_WHILE_207(p,o,s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s)
#define BOOST_PP_WHILE_208(p,o,s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s)
#define BOOST_PP_WHILE_209(p,o,s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s)
#define BOOST_PP_WHILE_210(p,o,s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s)
#define BOOST_PP_WHILE_211(p,o,s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s)
#define BOOST_PP_WHILE_212(p,o,s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s)
#define BOOST_PP_WHILE_213(p,o,s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s)
#define BOOST_PP_WHILE_214(p,o,s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s)
#define BOOST_PP_WHILE_215(p,o,s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s)
#define BOOST_PP_WHILE_216(p,o,s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s)
#define BOOST_PP_WHILE_217(p,o,s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s)
#define BOOST_PP_WHILE_218(p,o,s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s)
#define BOOST_PP_WHILE_219(p,o,s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s)
#define BOOST_PP_WHILE_220(p,o,s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s)
#define BOOST_PP_WHILE_221(p,o,s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s)
#define BOOST_PP_WHILE_222(p,o,s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s)
#define BOOST_PP_WHILE_223(p,o,s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s)
#define BOOST_PP_WHILE_224(p,o,s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s)
#define BOOST_PP_WHILE_225(p,o,s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s)
#define BOOST_PP_WHILE_226(p,o,s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s)
#define BOOST_PP_WHILE_227(p,o,s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s)
#define BOOST_PP_WHILE_228(p,o,s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s)
#define BOOST_PP_WHILE_229(p,o,s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s)
#define BOOST_PP_WHILE_230(p,o,s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s)
#define BOOST_PP_WHILE_231(p,o,s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s)
#define BOOST_PP_WHILE_232(p,o,s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s)
#define BOOST_PP_WHILE_233(p,o,s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s)
#define BOOST_PP_WHILE_234(p,o,s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s)
#define BOOST_PP_WHILE_235(p,o,s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s)
#define BOOST_PP_WHILE_236(p,o,s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s)
#define BOOST_PP_WHILE_237(p,o,s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s)
#define BOOST_PP_WHILE_238(p,o,s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s)
#define BOOST_PP_WHILE_239(p,o,s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s)
#define BOOST_PP_WHILE_240(p,o,s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s)
#define BOOST_PP_WHILE_241(p,o,s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s)
#define BOOST_PP_WHILE_242(p,o,s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s)
#define BOOST_PP_WHILE_243(p,o,s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s)
#define BOOST_PP_WHILE_244(p,o,s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s)
#define BOOST_PP_WHILE_245(p,o,s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s)
#define BOOST_PP_WHILE_246(p,o,s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s)
#define BOOST_PP_WHILE_247(p,o,s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s)
#define BOOST_PP_WHILE_248(p,o,s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s)
#define BOOST_PP_WHILE_249(p,o,s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s)
#define BOOST_PP_WHILE_250(p,o,s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s)
#define BOOST_PP_WHILE_251(p,o,s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s)
#define BOOST_PP_WHILE_252(p,o,s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s)
#define BOOST_PP_WHILE_253(p,o,s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s)
#define BOOST_PP_WHILE_254(p,o,s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s)
#define BOOST_PP_WHILE_255(p,o,s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s)
#define BOOST_PP_WHILE_256(p,o,s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s)

#define BOOST_PP_WHILE_1_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
#define BOOST_PP_WHILE_2_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
#define BOOST_PP_WHILE_3_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
#define BOOST_PP_WHILE_4_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
#define BOOST_PP_WHILE_5_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s))
#define BOOST_PP_WHILE_6_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s))
#define BOOST_PP_WHILE_7_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s))
#define BOOST_PP_WHILE_8_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s))
#define BOOST_PP_WHILE_9_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s))
#define BOOST_PP_WHILE_10_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s))
#define BOOST_PP_WHILE_11_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s))
#define BOOST_PP_WHILE_12_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s))
#define BOOST_PP_WHILE_13_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s))
#define BOOST_PP_WHILE_14_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s))
#define BOOST_PP_WHILE_15_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s))
#define BOOST_PP_WHILE_16_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s))
#define BOOST_PP_WHILE_17_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s))
#define BOOST_PP_WHILE_18_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s))
#define BOOST_PP_WHILE_19_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s))
#define BOOST_PP_WHILE_20_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s))
#define BOOST_PP_WHILE_21_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s))
#define BOOST_PP_WHILE_22_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s))
#define BOOST_PP_WHILE_23_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s))
#define BOOST_PP_WHILE_24_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s))
#define BOOST_PP_WHILE_25_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s))
#define BOOST_PP_WHILE_26_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s))
#define BOOST_PP_WHILE_27_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s))
#define BOOST_PP_WHILE_28_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s))
#define BOOST_PP_WHILE_29_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s))
#define BOOST_PP_WHILE_30_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s))
#define BOOST_PP_WHILE_31_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s))
#define BOOST_PP_WHILE_32_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s))
#define BOOST_PP_WHILE_33_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s))
#define BOOST_PP_WHILE_34_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s))
#define BOOST_PP_WHILE_35_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s))
#define BOOST_PP_WHILE_36_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s))
#define BOOST_PP_WHILE_37_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s))
#define BOOST_PP_WHILE_38_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s))
#define BOOST_PP_WHILE_39_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s))
#define BOOST_PP_WHILE_40_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s))
#define BOOST_PP_WHILE_41_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s))
#define BOOST_PP_WHILE_42_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s))
#define BOOST_PP_WHILE_43_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s))
#define BOOST_PP_WHILE_44_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s))
#define BOOST_PP_WHILE_45_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s))
#define BOOST_PP_WHILE_46_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s))
#define BOOST_PP_WHILE_47_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s))
#define BOOST_PP_WHILE_48_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s))
#define BOOST_PP_WHILE_49_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s))
#define BOOST_PP_WHILE_50_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s))
#define BOOST_PP_WHILE_51_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s))
#define BOOST_PP_WHILE_52_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s))
#define BOOST_PP_WHILE_53_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s))
#define BOOST_PP_WHILE_54_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s))
#define BOOST_PP_WHILE_55_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s))
#define BOOST_PP_WHILE_56_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s))
#define BOOST_PP_WHILE_57_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s))
#define BOOST_PP_WHILE_58_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s))
#define BOOST_PP_WHILE_59_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s))
#define BOOST_PP_WHILE_60_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s))
#define BOOST_PP_WHILE_61_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s))
#define BOOST_PP_WHILE_62_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s))
#define BOOST_PP_WHILE_63_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s))
#define BOOST_PP_WHILE_64_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s))
#define BOOST_PP_WHILE_65_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s))
#define BOOST_PP_WHILE_66_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s))
#define BOOST_PP_WHILE_67_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s))
#define BOOST_PP_WHILE_68_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s))
#define BOOST_PP_WHILE_69_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s))
#define BOOST_PP_WHILE_70_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s))
#define BOOST_PP_WHILE_71_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s))
#define BOOST_PP_WHILE_72_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s))
#define BOOST_PP_WHILE_73_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s))
#define BOOST_PP_WHILE_74_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s))
#define BOOST_PP_WHILE_75_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s))
#define BOOST_PP_WHILE_76_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s))
#define BOOST_PP_WHILE_77_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s))
#define BOOST_PP_WHILE_78_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s))
#define BOOST_PP_WHILE_79_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s))
#define BOOST_PP_WHILE_80_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s))
#define BOOST_PP_WHILE_81_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s))
#define BOOST_PP_WHILE_82_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s))
#define BOOST_PP_WHILE_83_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s))
#define BOOST_PP_WHILE_84_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s))
#define BOOST_PP_WHILE_85_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s))
#define BOOST_PP_WHILE_86_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s))
#define BOOST_PP_WHILE_87_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s))
#define BOOST_PP_WHILE_88_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s))
#define BOOST_PP_WHILE_89_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s))
#define BOOST_PP_WHILE_90_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s))
#define BOOST_PP_WHILE_91_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s))
#define BOOST_PP_WHILE_92_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s))
#define BOOST_PP_WHILE_93_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s))
#define BOOST_PP_WHILE_94_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s))
#define BOOST_PP_WHILE_95_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s))
#define BOOST_PP_WHILE_96_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s))
#define BOOST_PP_WHILE_97_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s))
#define BOOST_PP_WHILE_98_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s))
#define BOOST_PP_WHILE_99_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s))
#define BOOST_PP_WHILE_100_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s))
#define BOOST_PP_WHILE_101_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s))
#define BOOST_PP_WHILE_102_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s))
#define BOOST_PP_WHILE_103_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s))
#define BOOST_PP_WHILE_104_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s))
#define BOOST_PP_WHILE_105_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s))
#define BOOST_PP_WHILE_106_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s))
#define BOOST_PP_WHILE_107_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s))
#define BOOST_PP_WHILE_108_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s))
#define BOOST_PP_WHILE_109_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s))
#define BOOST_PP_WHILE_110_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s))
#define BOOST_PP_WHILE_111_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s))
#define BOOST_PP_WHILE_112_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s))
#define BOOST_PP_WHILE_113_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s))
#define BOOST_PP_WHILE_114_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s))
#define BOOST_PP_WHILE_115_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s))
#define BOOST_PP_WHILE_116_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s))
#define BOOST_PP_WHILE_117_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s))
#define BOOST_PP_WHILE_118_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s))
#define BOOST_PP_WHILE_119_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s))
#define BOOST_PP_WHILE_120_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s))
#define BOOST_PP_WHILE_121_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s))
#define BOOST_PP_WHILE_122_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s))
#define BOOST_PP_WHILE_123_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s))
#define BOOST_PP_WHILE_124_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s))
#define BOOST_PP_WHILE_125_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s))
#define BOOST_PP_WHILE_126_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s))
#define BOOST_PP_WHILE_127_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s))
#define BOOST_PP_WHILE_128_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
#define BOOST_PP_WHILE_129_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s))
#define BOOST_PP_WHILE_130_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s))
#define BOOST_PP_WHILE_131_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s))
#define BOOST_PP_WHILE_132_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s))
#define BOOST_PP_WHILE_133_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s))
#define BOOST_PP_WHILE_134_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s))
#define BOOST_PP_WHILE_135_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s))
#define BOOST_PP_WHILE_136_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s))
#define BOOST_PP_WHILE_137_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s))
#define BOOST_PP_WHILE_138_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s))
#define BOOST_PP_WHILE_139_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s))
#define BOOST_PP_WHILE_140_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s))
#define BOOST_PP_WHILE_141_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s))
#define BOOST_PP_WHILE_142_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s))
#define BOOST_PP_WHILE_143_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s))
#define BOOST_PP_WHILE_144_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s))
#define BOOST_PP_WHILE_145_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s))
#define BOOST_PP_WHILE_146_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s))
#define BOOST_PP_WHILE_147_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s))
#define BOOST_PP_WHILE_148_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s))
#define BOOST_PP_WHILE_149_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s))
#define BOOST_PP_WHILE_150_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s))
#define BOOST_PP_WHILE_151_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s))
#define BOOST_PP_WHILE_152_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s))
#define BOOST_PP_WHILE_153_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s))
#define BOOST_PP_WHILE_154_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s))
#define BOOST_PP_WHILE_155_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s))
#define BOOST_PP_WHILE_156_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s))
#define BOOST_PP_WHILE_157_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s))
#define BOOST_PP_WHILE_158_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s))
#define BOOST_PP_WHILE_159_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s))
#define BOOST_PP_WHILE_160_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s))
#define BOOST_PP_WHILE_161_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s))
#define BOOST_PP_WHILE_162_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s))
#define BOOST_PP_WHILE_163_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s))
#define BOOST_PP_WHILE_164_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s))
#define BOOST_PP_WHILE_165_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s))
#define BOOST_PP_WHILE_166_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s))
#define BOOST_PP_WHILE_167_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s))
#define BOOST_PP_WHILE_168_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s))
#define BOOST_PP_WHILE_169_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s))
#define BOOST_PP_WHILE_170_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s))
#define BOOST_PP_WHILE_171_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s))
#define BOOST_PP_WHILE_172_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s))
#define BOOST_PP_WHILE_173_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s))
#define BOOST_PP_WHILE_174_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s))
#define BOOST_PP_WHILE_175_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s))
#define BOOST_PP_WHILE_176_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s))
#define BOOST_PP_WHILE_177_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s))
#define BOOST_PP_WHILE_178_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s))
#define BOOST_PP_WHILE_179_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s))
#define BOOST_PP_WHILE_180_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s))
#define BOOST_PP_WHILE_181_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s))
#define BOOST_PP_WHILE_182_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s))
#define BOOST_PP_WHILE_183_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s))
#define BOOST_PP_WHILE_184_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s))
#define BOOST_PP_WHILE_185_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s))
#define BOOST_PP_WHILE_186_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s))
#define BOOST_PP_WHILE_187_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s))
#define BOOST_PP_WHILE_188_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s))
#define BOOST_PP_WHILE_189_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s))
#define BOOST_PP_WHILE_190_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s))
#define BOOST_PP_WHILE_191_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s))
#define BOOST_PP_WHILE_192_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s))
#define BOOST_PP_WHILE_193_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s))
#define BOOST_PP_WHILE_194_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s))
#define BOOST_PP_WHILE_195_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s))
#define BOOST_PP_WHILE_196_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s))
#define BOOST_PP_WHILE_197_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s))
#define BOOST_PP_WHILE_198_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s))
#define BOOST_PP_WHILE_199_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s))
#define BOOST_PP_WHILE_200_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s))
#define BOOST_PP_WHILE_201_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s))
#define BOOST_PP_WHILE_202_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s))
#define BOOST_PP_WHILE_203_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s))
#define BOOST_PP_WHILE_204_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s))
#define BOOST_PP_WHILE_205_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s))
#define BOOST_PP_WHILE_206_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s))
#define BOOST_PP_WHILE_207_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s))
#define BOOST_PP_WHILE_208_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s))
#define BOOST_PP_WHILE_209_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s))
#define BOOST_PP_WHILE_210_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s))
#define BOOST_PP_WHILE_211_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s))
#define BOOST_PP_WHILE_212_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s))
#define BOOST_PP_WHILE_213_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s))
#define BOOST_PP_WHILE_214_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s))
#define BOOST_PP_WHILE_215_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s))
#define BOOST_PP_WHILE_216_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s))
#define BOOST_PP_WHILE_217_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s))
#define BOOST_PP_WHILE_218_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s))
#define BOOST_PP_WHILE_219_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s))
#define BOOST_PP_WHILE_220_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s))
#define BOOST_PP_WHILE_221_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s))
#define BOOST_PP_WHILE_222_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s))
#define BOOST_PP_WHILE_223_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s))
#define BOOST_PP_WHILE_224_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s))
#define BOOST_PP_WHILE_225_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s))
#define BOOST_PP_WHILE_226_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s))
#define BOOST_PP_WHILE_227_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s))
#define BOOST_PP_WHILE_228_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s))
#define BOOST_PP_WHILE_229_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s))
#define BOOST_PP_WHILE_230_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s))
#define BOOST_PP_WHILE_231_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s))
#define BOOST_PP_WHILE_232_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s))
#define BOOST_PP_WHILE_233_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s))
#define BOOST_PP_WHILE_234_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s))
#define BOOST_PP_WHILE_235_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s))
#define BOOST_PP_WHILE_236_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s))
#define BOOST_PP_WHILE_237_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s))
#define BOOST_PP_WHILE_238_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s))
#define BOOST_PP_WHILE_239_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s))
#define BOOST_PP_WHILE_240_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s))
#define BOOST_PP_WHILE_241_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s))
#define BOOST_PP_WHILE_242_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s))
#define BOOST_PP_WHILE_243_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s))
#define BOOST_PP_WHILE_244_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s))
#define BOOST_PP_WHILE_245_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s))
#define BOOST_PP_WHILE_246_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s))
#define BOOST_PP_WHILE_247_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s))
#define BOOST_PP_WHILE_248_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s))
#define BOOST_PP_WHILE_249_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s))
#define BOOST_PP_WHILE_250_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s))
#define BOOST_PP_WHILE_251_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s))
#define BOOST_PP_WHILE_252_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s))
#define BOOST_PP_WHILE_253_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s))
#define BOOST_PP_WHILE_254_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s))
#define BOOST_PP_WHILE_255_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s))
#define BOOST_PP_WHILE_256_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s))
# 49 "/usr/include/boost-1_41/boost/preprocessor/control/while.hpp" 2


#define BOOST_PP_WHILE_257(p,o,s) BOOST_PP_ERROR(0x0001)

#define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1

#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p,o,s) 0
# 21 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/add.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/tuple/elem.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/tuple/elem.hpp"
#define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP 




#define BOOST_PP_TUPLE_ELEM(size,index,tuple) BOOST_PP_TUPLE_ELEM_I(size, index, tuple)
# 32 "/usr/include/boost-1_41/boost/preprocessor/tuple/elem.hpp"
#define BOOST_PP_TUPLE_ELEM_I(s,i,t) BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t


#define BOOST_PP_TUPLE_ELEM_1_0(a) a

#define BOOST_PP_TUPLE_ELEM_2_0(a,b) a
#define BOOST_PP_TUPLE_ELEM_2_1(a,b) b

#define BOOST_PP_TUPLE_ELEM_3_0(a,b,c) a
#define BOOST_PP_TUPLE_ELEM_3_1(a,b,c) b
#define BOOST_PP_TUPLE_ELEM_3_2(a,b,c) c

#define BOOST_PP_TUPLE_ELEM_4_0(a,b,c,d) a
#define BOOST_PP_TUPLE_ELEM_4_1(a,b,c,d) b
#define BOOST_PP_TUPLE_ELEM_4_2(a,b,c,d) c
#define BOOST_PP_TUPLE_ELEM_4_3(a,b,c,d) d

#define BOOST_PP_TUPLE_ELEM_5_0(a,b,c,d,e) a
#define BOOST_PP_TUPLE_ELEM_5_1(a,b,c,d,e) b
#define BOOST_PP_TUPLE_ELEM_5_2(a,b,c,d,e) c
#define BOOST_PP_TUPLE_ELEM_5_3(a,b,c,d,e) d
#define BOOST_PP_TUPLE_ELEM_5_4(a,b,c,d,e) e

#define BOOST_PP_TUPLE_ELEM_6_0(a,b,c,d,e,f) a
#define BOOST_PP_TUPLE_ELEM_6_1(a,b,c,d,e,f) b
#define BOOST_PP_TUPLE_ELEM_6_2(a,b,c,d,e,f) c
#define BOOST_PP_TUPLE_ELEM_6_3(a,b,c,d,e,f) d
#define BOOST_PP_TUPLE_ELEM_6_4(a,b,c,d,e,f) e
#define BOOST_PP_TUPLE_ELEM_6_5(a,b,c,d,e,f) f

#define BOOST_PP_TUPLE_ELEM_7_0(a,b,c,d,e,f,g) a
#define BOOST_PP_TUPLE_ELEM_7_1(a,b,c,d,e,f,g) b
#define BOOST_PP_TUPLE_ELEM_7_2(a,b,c,d,e,f,g) c
#define BOOST_PP_TUPLE_ELEM_7_3(a,b,c,d,e,f,g) d
#define BOOST_PP_TUPLE_ELEM_7_4(a,b,c,d,e,f,g) e
#define BOOST_PP_TUPLE_ELEM_7_5(a,b,c,d,e,f,g) f
#define BOOST_PP_TUPLE_ELEM_7_6(a,b,c,d,e,f,g) g

#define BOOST_PP_TUPLE_ELEM_8_0(a,b,c,d,e,f,g,h) a
#define BOOST_PP_TUPLE_ELEM_8_1(a,b,c,d,e,f,g,h) b
#define BOOST_PP_TUPLE_ELEM_8_2(a,b,c,d,e,f,g,h) c
#define BOOST_PP_TUPLE_ELEM_8_3(a,b,c,d,e,f,g,h) d
#define BOOST_PP_TUPLE_ELEM_8_4(a,b,c,d,e,f,g,h) e
#define BOOST_PP_TUPLE_ELEM_8_5(a,b,c,d,e,f,g,h) f
#define BOOST_PP_TUPLE_ELEM_8_6(a,b,c,d,e,f,g,h) g
#define BOOST_PP_TUPLE_ELEM_8_7(a,b,c,d,e,f,g,h) h

#define BOOST_PP_TUPLE_ELEM_9_0(a,b,c,d,e,f,g,h,i) a
#define BOOST_PP_TUPLE_ELEM_9_1(a,b,c,d,e,f,g,h,i) b
#define BOOST_PP_TUPLE_ELEM_9_2(a,b,c,d,e,f,g,h,i) c
#define BOOST_PP_TUPLE_ELEM_9_3(a,b,c,d,e,f,g,h,i) d
#define BOOST_PP_TUPLE_ELEM_9_4(a,b,c,d,e,f,g,h,i) e
#define BOOST_PP_TUPLE_ELEM_9_5(a,b,c,d,e,f,g,h,i) f
#define BOOST_PP_TUPLE_ELEM_9_6(a,b,c,d,e,f,g,h,i) g
#define BOOST_PP_TUPLE_ELEM_9_7(a,b,c,d,e,f,g,h,i) h
#define BOOST_PP_TUPLE_ELEM_9_8(a,b,c,d,e,f,g,h,i) i

#define BOOST_PP_TUPLE_ELEM_10_0(a,b,c,d,e,f,g,h,i,j) a
#define BOOST_PP_TUPLE_ELEM_10_1(a,b,c,d,e,f,g,h,i,j) b
#define BOOST_PP_TUPLE_ELEM_10_2(a,b,c,d,e,f,g,h,i,j) c
#define BOOST_PP_TUPLE_ELEM_10_3(a,b,c,d,e,f,g,h,i,j) d
#define BOOST_PP_TUPLE_ELEM_10_4(a,b,c,d,e,f,g,h,i,j) e
#define BOOST_PP_TUPLE_ELEM_10_5(a,b,c,d,e,f,g,h,i,j) f
#define BOOST_PP_TUPLE_ELEM_10_6(a,b,c,d,e,f,g,h,i,j) g
#define BOOST_PP_TUPLE_ELEM_10_7(a,b,c,d,e,f,g,h,i,j) h
#define BOOST_PP_TUPLE_ELEM_10_8(a,b,c,d,e,f,g,h,i,j) i
#define BOOST_PP_TUPLE_ELEM_10_9(a,b,c,d,e,f,g,h,i,j) j

#define BOOST_PP_TUPLE_ELEM_11_0(a,b,c,d,e,f,g,h,i,j,k) a
#define BOOST_PP_TUPLE_ELEM_11_1(a,b,c,d,e,f,g,h,i,j,k) b
#define BOOST_PP_TUPLE_ELEM_11_2(a,b,c,d,e,f,g,h,i,j,k) c
#define BOOST_PP_TUPLE_ELEM_11_3(a,b,c,d,e,f,g,h,i,j,k) d
#define BOOST_PP_TUPLE_ELEM_11_4(a,b,c,d,e,f,g,h,i,j,k) e
#define BOOST_PP_TUPLE_ELEM_11_5(a,b,c,d,e,f,g,h,i,j,k) f
#define BOOST_PP_TUPLE_ELEM_11_6(a,b,c,d,e,f,g,h,i,j,k) g
#define BOOST_PP_TUPLE_ELEM_11_7(a,b,c,d,e,f,g,h,i,j,k) h
#define BOOST_PP_TUPLE_ELEM_11_8(a,b,c,d,e,f,g,h,i,j,k) i
#define BOOST_PP_TUPLE_ELEM_11_9(a,b,c,d,e,f,g,h,i,j,k) j
#define BOOST_PP_TUPLE_ELEM_11_10(a,b,c,d,e,f,g,h,i,j,k) k

#define BOOST_PP_TUPLE_ELEM_12_0(a,b,c,d,e,f,g,h,i,j,k,l) a
#define BOOST_PP_TUPLE_ELEM_12_1(a,b,c,d,e,f,g,h,i,j,k,l) b
#define BOOST_PP_TUPLE_ELEM_12_2(a,b,c,d,e,f,g,h,i,j,k,l) c
#define BOOST_PP_TUPLE_ELEM_12_3(a,b,c,d,e,f,g,h,i,j,k,l) d
#define BOOST_PP_TUPLE_ELEM_12_4(a,b,c,d,e,f,g,h,i,j,k,l) e
#define BOOST_PP_TUPLE_ELEM_12_5(a,b,c,d,e,f,g,h,i,j,k,l) f
#define BOOST_PP_TUPLE_ELEM_12_6(a,b,c,d,e,f,g,h,i,j,k,l) g
#define BOOST_PP_TUPLE_ELEM_12_7(a,b,c,d,e,f,g,h,i,j,k,l) h
#define BOOST_PP_TUPLE_ELEM_12_8(a,b,c,d,e,f,g,h,i,j,k,l) i
#define BOOST_PP_TUPLE_ELEM_12_9(a,b,c,d,e,f,g,h,i,j,k,l) j
#define BOOST_PP_TUPLE_ELEM_12_10(a,b,c,d,e,f,g,h,i,j,k,l) k
#define BOOST_PP_TUPLE_ELEM_12_11(a,b,c,d,e,f,g,h,i,j,k,l) l

#define BOOST_PP_TUPLE_ELEM_13_0(a,b,c,d,e,f,g,h,i,j,k,l,m) a
#define BOOST_PP_TUPLE_ELEM_13_1(a,b,c,d,e,f,g,h,i,j,k,l,m) b
#define BOOST_PP_TUPLE_ELEM_13_2(a,b,c,d,e,f,g,h,i,j,k,l,m) c
#define BOOST_PP_TUPLE_ELEM_13_3(a,b,c,d,e,f,g,h,i,j,k,l,m) d
#define BOOST_PP_TUPLE_ELEM_13_4(a,b,c,d,e,f,g,h,i,j,k,l,m) e
#define BOOST_PP_TUPLE_ELEM_13_5(a,b,c,d,e,f,g,h,i,j,k,l,m) f
#define BOOST_PP_TUPLE_ELEM_13_6(a,b,c,d,e,f,g,h,i,j,k,l,m) g
#define BOOST_PP_TUPLE_ELEM_13_7(a,b,c,d,e,f,g,h,i,j,k,l,m) h
#define BOOST_PP_TUPLE_ELEM_13_8(a,b,c,d,e,f,g,h,i,j,k,l,m) i
#define BOOST_PP_TUPLE_ELEM_13_9(a,b,c,d,e,f,g,h,i,j,k,l,m) j
#define BOOST_PP_TUPLE_ELEM_13_10(a,b,c,d,e,f,g,h,i,j,k,l,m) k
#define BOOST_PP_TUPLE_ELEM_13_11(a,b,c,d,e,f,g,h,i,j,k,l,m) l
#define BOOST_PP_TUPLE_ELEM_13_12(a,b,c,d,e,f,g,h,i,j,k,l,m) m

#define BOOST_PP_TUPLE_ELEM_14_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n) a
#define BOOST_PP_TUPLE_ELEM_14_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n) b
#define BOOST_PP_TUPLE_ELEM_14_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n) c
#define BOOST_PP_TUPLE_ELEM_14_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n) d
#define BOOST_PP_TUPLE_ELEM_14_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n) e
#define BOOST_PP_TUPLE_ELEM_14_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n) f
#define BOOST_PP_TUPLE_ELEM_14_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n) g
#define BOOST_PP_TUPLE_ELEM_14_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n) h
#define BOOST_PP_TUPLE_ELEM_14_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n) i
#define BOOST_PP_TUPLE_ELEM_14_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n) j
#define BOOST_PP_TUPLE_ELEM_14_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n) k
#define BOOST_PP_TUPLE_ELEM_14_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n) l
#define BOOST_PP_TUPLE_ELEM_14_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n) m
#define BOOST_PP_TUPLE_ELEM_14_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n) n

#define BOOST_PP_TUPLE_ELEM_15_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) a
#define BOOST_PP_TUPLE_ELEM_15_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) b
#define BOOST_PP_TUPLE_ELEM_15_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) c
#define BOOST_PP_TUPLE_ELEM_15_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) d
#define BOOST_PP_TUPLE_ELEM_15_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) e
#define BOOST_PP_TUPLE_ELEM_15_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) f
#define BOOST_PP_TUPLE_ELEM_15_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) g
#define BOOST_PP_TUPLE_ELEM_15_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) h
#define BOOST_PP_TUPLE_ELEM_15_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) i
#define BOOST_PP_TUPLE_ELEM_15_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) j
#define BOOST_PP_TUPLE_ELEM_15_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) k
#define BOOST_PP_TUPLE_ELEM_15_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) l
#define BOOST_PP_TUPLE_ELEM_15_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) m
#define BOOST_PP_TUPLE_ELEM_15_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) n
#define BOOST_PP_TUPLE_ELEM_15_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) o

#define BOOST_PP_TUPLE_ELEM_16_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) a
#define BOOST_PP_TUPLE_ELEM_16_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) b
#define BOOST_PP_TUPLE_ELEM_16_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) c
#define BOOST_PP_TUPLE_ELEM_16_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) d
#define BOOST_PP_TUPLE_ELEM_16_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) e
#define BOOST_PP_TUPLE_ELEM_16_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) f
#define BOOST_PP_TUPLE_ELEM_16_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) g
#define BOOST_PP_TUPLE_ELEM_16_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) h
#define BOOST_PP_TUPLE_ELEM_16_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) i
#define BOOST_PP_TUPLE_ELEM_16_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) j
#define BOOST_PP_TUPLE_ELEM_16_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) k
#define BOOST_PP_TUPLE_ELEM_16_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) l
#define BOOST_PP_TUPLE_ELEM_16_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) m
#define BOOST_PP_TUPLE_ELEM_16_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) n
#define BOOST_PP_TUPLE_ELEM_16_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) o
#define BOOST_PP_TUPLE_ELEM_16_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) p

#define BOOST_PP_TUPLE_ELEM_17_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) a
#define BOOST_PP_TUPLE_ELEM_17_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) b
#define BOOST_PP_TUPLE_ELEM_17_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) c
#define BOOST_PP_TUPLE_ELEM_17_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) d
#define BOOST_PP_TUPLE_ELEM_17_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) e
#define BOOST_PP_TUPLE_ELEM_17_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) f
#define BOOST_PP_TUPLE_ELEM_17_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) g
#define BOOST_PP_TUPLE_ELEM_17_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) h
#define BOOST_PP_TUPLE_ELEM_17_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) i
#define BOOST_PP_TUPLE_ELEM_17_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) j
#define BOOST_PP_TUPLE_ELEM_17_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) k
#define BOOST_PP_TUPLE_ELEM_17_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) l
#define BOOST_PP_TUPLE_ELEM_17_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) m
#define BOOST_PP_TUPLE_ELEM_17_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) n
#define BOOST_PP_TUPLE_ELEM_17_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) o
#define BOOST_PP_TUPLE_ELEM_17_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) p
#define BOOST_PP_TUPLE_ELEM_17_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) q

#define BOOST_PP_TUPLE_ELEM_18_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) a
#define BOOST_PP_TUPLE_ELEM_18_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) b
#define BOOST_PP_TUPLE_ELEM_18_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) c
#define BOOST_PP_TUPLE_ELEM_18_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) d
#define BOOST_PP_TUPLE_ELEM_18_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) e
#define BOOST_PP_TUPLE_ELEM_18_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) f
#define BOOST_PP_TUPLE_ELEM_18_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) g
#define BOOST_PP_TUPLE_ELEM_18_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) h
#define BOOST_PP_TUPLE_ELEM_18_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) i
#define BOOST_PP_TUPLE_ELEM_18_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) j
#define BOOST_PP_TUPLE_ELEM_18_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) k
#define BOOST_PP_TUPLE_ELEM_18_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) l
#define BOOST_PP_TUPLE_ELEM_18_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) m
#define BOOST_PP_TUPLE_ELEM_18_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) n
#define BOOST_PP_TUPLE_ELEM_18_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) o
#define BOOST_PP_TUPLE_ELEM_18_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) p
#define BOOST_PP_TUPLE_ELEM_18_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) q
#define BOOST_PP_TUPLE_ELEM_18_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) r

#define BOOST_PP_TUPLE_ELEM_19_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) a
#define BOOST_PP_TUPLE_ELEM_19_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) b
#define BOOST_PP_TUPLE_ELEM_19_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) c
#define BOOST_PP_TUPLE_ELEM_19_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) d
#define BOOST_PP_TUPLE_ELEM_19_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) e
#define BOOST_PP_TUPLE_ELEM_19_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) f
#define BOOST_PP_TUPLE_ELEM_19_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) g
#define BOOST_PP_TUPLE_ELEM_19_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) h
#define BOOST_PP_TUPLE_ELEM_19_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) i
#define BOOST_PP_TUPLE_ELEM_19_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) j
#define BOOST_PP_TUPLE_ELEM_19_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) k
#define BOOST_PP_TUPLE_ELEM_19_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) l
#define BOOST_PP_TUPLE_ELEM_19_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) m
#define BOOST_PP_TUPLE_ELEM_19_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) n
#define BOOST_PP_TUPLE_ELEM_19_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) o
#define BOOST_PP_TUPLE_ELEM_19_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) p
#define BOOST_PP_TUPLE_ELEM_19_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) q
#define BOOST_PP_TUPLE_ELEM_19_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) r
#define BOOST_PP_TUPLE_ELEM_19_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) s

#define BOOST_PP_TUPLE_ELEM_20_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) a
#define BOOST_PP_TUPLE_ELEM_20_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) b
#define BOOST_PP_TUPLE_ELEM_20_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) c
#define BOOST_PP_TUPLE_ELEM_20_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) d
#define BOOST_PP_TUPLE_ELEM_20_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) e
#define BOOST_PP_TUPLE_ELEM_20_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) f
#define BOOST_PP_TUPLE_ELEM_20_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) g
#define BOOST_PP_TUPLE_ELEM_20_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) h
#define BOOST_PP_TUPLE_ELEM_20_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) i
#define BOOST_PP_TUPLE_ELEM_20_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) j
#define BOOST_PP_TUPLE_ELEM_20_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) k
#define BOOST_PP_TUPLE_ELEM_20_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) l
#define BOOST_PP_TUPLE_ELEM_20_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) m
#define BOOST_PP_TUPLE_ELEM_20_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) n
#define BOOST_PP_TUPLE_ELEM_20_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) o
#define BOOST_PP_TUPLE_ELEM_20_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) p
#define BOOST_PP_TUPLE_ELEM_20_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) q
#define BOOST_PP_TUPLE_ELEM_20_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) r
#define BOOST_PP_TUPLE_ELEM_20_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) s
#define BOOST_PP_TUPLE_ELEM_20_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) t

#define BOOST_PP_TUPLE_ELEM_21_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) a
#define BOOST_PP_TUPLE_ELEM_21_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) b
#define BOOST_PP_TUPLE_ELEM_21_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) c
#define BOOST_PP_TUPLE_ELEM_21_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) d
#define BOOST_PP_TUPLE_ELEM_21_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) e
#define BOOST_PP_TUPLE_ELEM_21_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) f
#define BOOST_PP_TUPLE_ELEM_21_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) g
#define BOOST_PP_TUPLE_ELEM_21_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) h
#define BOOST_PP_TUPLE_ELEM_21_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) i
#define BOOST_PP_TUPLE_ELEM_21_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) j
#define BOOST_PP_TUPLE_ELEM_21_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) k
#define BOOST_PP_TUPLE_ELEM_21_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) l
#define BOOST_PP_TUPLE_ELEM_21_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) m
#define BOOST_PP_TUPLE_ELEM_21_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) n
#define BOOST_PP_TUPLE_ELEM_21_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) o
#define BOOST_PP_TUPLE_ELEM_21_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) p
#define BOOST_PP_TUPLE_ELEM_21_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) q
#define BOOST_PP_TUPLE_ELEM_21_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) r
#define BOOST_PP_TUPLE_ELEM_21_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) s
#define BOOST_PP_TUPLE_ELEM_21_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) t
#define BOOST_PP_TUPLE_ELEM_21_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) u

#define BOOST_PP_TUPLE_ELEM_22_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) a
#define BOOST_PP_TUPLE_ELEM_22_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) b
#define BOOST_PP_TUPLE_ELEM_22_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) c
#define BOOST_PP_TUPLE_ELEM_22_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) d
#define BOOST_PP_TUPLE_ELEM_22_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) e
#define BOOST_PP_TUPLE_ELEM_22_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) f
#define BOOST_PP_TUPLE_ELEM_22_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) g
#define BOOST_PP_TUPLE_ELEM_22_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) h
#define BOOST_PP_TUPLE_ELEM_22_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) i
#define BOOST_PP_TUPLE_ELEM_22_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) j
#define BOOST_PP_TUPLE_ELEM_22_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) k
#define BOOST_PP_TUPLE_ELEM_22_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) l
#define BOOST_PP_TUPLE_ELEM_22_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) m
#define BOOST_PP_TUPLE_ELEM_22_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) n
#define BOOST_PP_TUPLE_ELEM_22_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) o
#define BOOST_PP_TUPLE_ELEM_22_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) p
#define BOOST_PP_TUPLE_ELEM_22_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) q
#define BOOST_PP_TUPLE_ELEM_22_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) r
#define BOOST_PP_TUPLE_ELEM_22_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) s
#define BOOST_PP_TUPLE_ELEM_22_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) t
#define BOOST_PP_TUPLE_ELEM_22_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) u
#define BOOST_PP_TUPLE_ELEM_22_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) v

#define BOOST_PP_TUPLE_ELEM_23_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) a
#define BOOST_PP_TUPLE_ELEM_23_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) b
#define BOOST_PP_TUPLE_ELEM_23_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) c
#define BOOST_PP_TUPLE_ELEM_23_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) d
#define BOOST_PP_TUPLE_ELEM_23_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) e
#define BOOST_PP_TUPLE_ELEM_23_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) f
#define BOOST_PP_TUPLE_ELEM_23_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) g
#define BOOST_PP_TUPLE_ELEM_23_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) h
#define BOOST_PP_TUPLE_ELEM_23_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) i
#define BOOST_PP_TUPLE_ELEM_23_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) j
#define BOOST_PP_TUPLE_ELEM_23_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) k
#define BOOST_PP_TUPLE_ELEM_23_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) l
#define BOOST_PP_TUPLE_ELEM_23_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) m
#define BOOST_PP_TUPLE_ELEM_23_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) n
#define BOOST_PP_TUPLE_ELEM_23_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) o
#define BOOST_PP_TUPLE_ELEM_23_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) p
#define BOOST_PP_TUPLE_ELEM_23_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) q
#define BOOST_PP_TUPLE_ELEM_23_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) r
#define BOOST_PP_TUPLE_ELEM_23_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) s
#define BOOST_PP_TUPLE_ELEM_23_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) t
#define BOOST_PP_TUPLE_ELEM_23_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) u
#define BOOST_PP_TUPLE_ELEM_23_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) v
#define BOOST_PP_TUPLE_ELEM_23_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) w

#define BOOST_PP_TUPLE_ELEM_24_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) a
#define BOOST_PP_TUPLE_ELEM_24_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) b
#define BOOST_PP_TUPLE_ELEM_24_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) c
#define BOOST_PP_TUPLE_ELEM_24_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) d
#define BOOST_PP_TUPLE_ELEM_24_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) e
#define BOOST_PP_TUPLE_ELEM_24_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) f
#define BOOST_PP_TUPLE_ELEM_24_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) g
#define BOOST_PP_TUPLE_ELEM_24_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) h
#define BOOST_PP_TUPLE_ELEM_24_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) i
#define BOOST_PP_TUPLE_ELEM_24_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) j
#define BOOST_PP_TUPLE_ELEM_24_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) k
#define BOOST_PP_TUPLE_ELEM_24_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) l
#define BOOST_PP_TUPLE_ELEM_24_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) m
#define BOOST_PP_TUPLE_ELEM_24_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) n
#define BOOST_PP_TUPLE_ELEM_24_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) o
#define BOOST_PP_TUPLE_ELEM_24_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) p
#define BOOST_PP_TUPLE_ELEM_24_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) q
#define BOOST_PP_TUPLE_ELEM_24_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) r
#define BOOST_PP_TUPLE_ELEM_24_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) s
#define BOOST_PP_TUPLE_ELEM_24_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) t
#define BOOST_PP_TUPLE_ELEM_24_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) u
#define BOOST_PP_TUPLE_ELEM_24_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) v
#define BOOST_PP_TUPLE_ELEM_24_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) w
#define BOOST_PP_TUPLE_ELEM_24_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) x

#define BOOST_PP_TUPLE_ELEM_25_0(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) a
#define BOOST_PP_TUPLE_ELEM_25_1(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) b
#define BOOST_PP_TUPLE_ELEM_25_2(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) c
#define BOOST_PP_TUPLE_ELEM_25_3(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) d
#define BOOST_PP_TUPLE_ELEM_25_4(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) e
#define BOOST_PP_TUPLE_ELEM_25_5(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) f
#define BOOST_PP_TUPLE_ELEM_25_6(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) g
#define BOOST_PP_TUPLE_ELEM_25_7(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) h
#define BOOST_PP_TUPLE_ELEM_25_8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) i
#define BOOST_PP_TUPLE_ELEM_25_9(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) j
#define BOOST_PP_TUPLE_ELEM_25_10(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) k
#define BOOST_PP_TUPLE_ELEM_25_11(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) l
#define BOOST_PP_TUPLE_ELEM_25_12(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) m
#define BOOST_PP_TUPLE_ELEM_25_13(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) n
#define BOOST_PP_TUPLE_ELEM_25_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) o
#define BOOST_PP_TUPLE_ELEM_25_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) p
#define BOOST_PP_TUPLE_ELEM_25_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) q
#define BOOST_PP_TUPLE_ELEM_25_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) r
#define BOOST_PP_TUPLE_ELEM_25_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) s
#define BOOST_PP_TUPLE_ELEM_25_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) t
#define BOOST_PP_TUPLE_ELEM_25_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) u
#define BOOST_PP_TUPLE_ELEM_25_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) v
#define BOOST_PP_TUPLE_ELEM_25_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) w
#define BOOST_PP_TUPLE_ELEM_25_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) x
#define BOOST_PP_TUPLE_ELEM_25_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) y
# 22 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/add.hpp" 2




#define BOOST_PP_ADD(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))





#define BOOST_PP_ADD_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)


#define BOOST_PP_ADD_O(d,xy) BOOST_PP_ADD_O_I xy




#define BOOST_PP_ADD_O_I(x,y) (BOOST_PP_INC(x), BOOST_PP_DEC(y))




#define BOOST_PP_ADD_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
# 67 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/sub.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/sub.hpp"
#define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP 
# 25 "/usr/include/boost-1_41/boost/preprocessor/arithmetic/sub.hpp"
#define BOOST_PP_SUB(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))





#define BOOST_PP_SUB_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)


#define BOOST_PP_SUB_O(d,xy) BOOST_PP_SUB_O_I xy




#define BOOST_PP_SUB_O_I(x,y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))




#define BOOST_PP_SUB_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
# 68 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2





#define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused,i,op) , BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(3, 1, op) , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) ) BOOST_PP_TUPLE_ELEM(3, 2, op)()






#define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i,param,value_func) BOOST_PP_REPEAT( BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC , (i, param, value_func) )
# 91 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))




#define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
# 29 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp" 2
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
#define BOOST_MPL_AUX_NA_PARAMS(i) BOOST_MPL_PP_ENUM(i, na)
# 56 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
#define BOOST_MPL_AUX_NA_SPEC_ARITY(i,name) 


#define BOOST_MPL_AUX_NA_SPEC_MAIN(i,name) template<> struct name< BOOST_MPL_AUX_NA_PARAMS(i) > { template< BOOST_MPL_PP_PARAMS(i, typename T) BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) > struct apply : name< BOOST_MPL_PP_PARAMS(i, T) > { }; };
# 98 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
#define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i,name) template< typename Tag > struct lambda< name< BOOST_MPL_AUX_NA_PARAMS(i) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) > { typedef false_ is_le; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; };
# 116 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
#define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i,j,name) namespace aux { template< BOOST_MPL_PP_PARAMS(j, typename T) > struct template_arity< name< BOOST_MPL_PP_PARAMS(j, T) > > : int_<j> { }; template<> struct template_arity< name< BOOST_MPL_PP_ENUM(i, na) > > : int_<-1> { }; }
# 149 "/usr/include/boost-1_41/boost/mpl/aux_/na_spec.hpp"
#define BOOST_MPL_AUX_NA_SPEC_ETI(i,name) 


#define BOOST_MPL_AUX_NA_PARAM(param) param = na

#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name)






#define BOOST_MPL_AUX_NA_SPEC(i,name) BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name)




#define BOOST_MPL_AUX_NA_SPEC2(i,j,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name)
# 20 "/usr/include/boost-1_41/boost/mpl/if.hpp" 2





namespace boost { namespace mpl {



template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};

template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};



template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = na
    >
struct if_
{
 private:

    typedef if_c<



          static_cast<bool>(T1::value)

        , T2
        , T3
        > almost_type_;

 public:
    typedef typename almost_type_::type type;

   
};
# 131 "/usr/include/boost-1_41/boost/mpl/if.hpp"
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_41/boost/mpl/eval_if.hpp" 2






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

}}
# 29 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2





# 1 "/usr/include/boost-1_41/boost/serialization/level_enum.hpp" 1

#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP 
# 19 "/usr/include/boost-1_41/boost/serialization/level_enum.hpp"
namespace boost {
namespace serialization {





enum level_type
{


    not_serializable = 0,






    primitive_type = 1,



    object_serializable = 2,







    object_class_info = 3
};

}
}
# 35 "/usr/include/boost-1_41/boost/serialization/level.hpp" 2

namespace boost {
namespace serialization {

struct basic_traits;


template<class T>
struct implementation_level_impl {
    template<class U>
    struct traits_class_level {
        typedef typename U::level type;
    };

    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_level<T>,

        typename mpl::eval_if<
            is_fundamental<T>,
            mpl::int_<primitive_type>,

        typename mpl::eval_if<
            is_class<T>,
            mpl::int_<object_class_info>,

        typename mpl::eval_if<
            is_array<T>,



                mpl::int_<object_serializable>,


        typename mpl::eval_if<
            is_enum<T>,



                mpl::int_<primitive_type>,


            mpl::int_<not_serializable>
        >
        >
        >
        >
        >::type type;

    static const int value = type::value;
};

template<class T>
struct implementation_level :
    public implementation_level_impl<const T>
{
};

template<class T, int L >
inline bool operator>=(implementation_level<T> t, enum level_type l)
{
    return t.value >= (int)l;
}

}
}



#define BOOST_CLASS_IMPLEMENTATION(T,E) namespace boost { namespace serialization { template <> struct implementation_level_impl< const T > { typedef mpl::integral_c_tag tag; typedef mpl::int_< E > type; BOOST_STATIC_CONSTANT( int, value = implementation_level_impl::type::value ); }; } }
# 32 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 1

#define BOOST_SERIALIZATION_TRACKING_HPP 
# 20 "/usr/include/boost-1_41/boost/serialization/tracking.hpp"
# 1 "/usr/include/boost-1_41/boost/static_assert.hpp" 1
# 15 "/usr/include/boost-1_41/boost/static_assert.hpp"
#define BOOST_STATIC_ASSERT_HPP 
# 36 "/usr/include/boost-1_41/boost/static_assert.hpp"
#define BOOST_STATIC_ASSERT_BOOL_CAST(x) ((x) == 0 ? false : true)
# 45 "/usr/include/boost-1_41/boost/static_assert.hpp"
namespace boost{


template <bool x> struct STATIC_ASSERTION_FAILURE;

template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };


template<int x> struct static_assert_test{};

}
# 116 "/usr/include/boost-1_41/boost/static_assert.hpp"
#define BOOST_STATIC_ASSERT(B) typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >)> BOOST_JOIN(boost_static_assert_typedef_, __LINE__)
# 21 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/identity.hpp" 1


#define BOOST_MPL_IDENTITY_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/identity.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct identity
{
    typedef T type;
   
};

template<
      typename T = na
    >
struct make_identity
{
    typedef identity<T> type;
   
};

template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }

}}
# 23 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/equal_to.hpp" 1


#define BOOST_MPL_EQUAL_TO_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/equal_to.hpp"
#define AUX778076_OP_NAME equal_to
#define AUX778076_OP_TOKEN ==
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/numeric_cast.hpp" 1


#define BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/mpl/numeric_cast.hpp"
#define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast


namespace boost { namespace mpl {



template< typename SourceTag, typename TargetTag > struct numeric_cast
{
    template< typename N > struct apply;
};

}}
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1






#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/has_apply.hpp" 1


#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/has_apply.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp" 1


#define BOOST_MPL_HAS_XXX_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/type_wrapper.hpp" 1


#define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/type_wrapper.hpp"
namespace boost { namespace mpl { namespace aux {

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






template< typename T > struct wrapped_type;

template< typename T > struct wrapped_type< type_wrapper<T> >
{
    typedef T type;
};







}}}
# 20 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/yes_no.hpp" 1


#define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/yes_no.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/arrays.hpp" 1


#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/yes_no.hpp" 2




namespace boost { namespace mpl { namespace aux {

typedef char (&no_tag)[1];
typedef char (&yes_tag)[2];

template< bool C_ > struct yes_no_tag
{
    typedef no_tag type;
};

template<> struct yes_no_tag<true>
{
    typedef yes_tag type;
};


template< long n > struct weighted_tag
{

    typedef char (&type)[n];




};
# 56 "/usr/include/boost-1_41/boost/mpl/aux_/yes_no.hpp"
}}}
# 21 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/has_xxx.hpp" 1


#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/msvc_typename.hpp" 1


#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/config/msvc_typename.hpp"
#define BOOST_MSVC_TYPENAME typename
# 23 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp" 2
# 228 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp"
#define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait,name,default_) template< typename T, typename fallback_ = boost::mpl::bool_<default_> > struct trait { 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<BOOST_MSVC_TYPENAME U::name>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; BOOST_STATIC_CONSTANT(bool, value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag) ); typedef boost::mpl::bool_<value> type; };
# 270 "/usr/include/boost-1_41/boost/mpl/has_xxx.hpp"
#define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false)
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/has_apply.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/has_apply.hpp" 1


#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/has_apply.hpp" 2

namespace boost { namespace mpl { namespace aux {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };







}}}
# 24 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_never_true.hpp" 1


#define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/use_preprocessed.hpp" 1


#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 
# 29 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 2




#define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 16 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/compiler.hpp" 1


#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED 
# 33 "/usr/include/boost-1_41/boost/mpl/aux_/config/compiler.hpp"
#define BOOST_MPL_CFG_COMPILER_DIR gcc
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2



# 1 "/usr/include/boost-1_41/boost/preprocessor/stringize.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/stringize.hpp"
#define BOOST_PREPROCESSOR_STRINGIZE_HPP 
# 28 "/usr/include/boost-1_41/boost/preprocessor/stringize.hpp"
#define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text)


#define BOOST_PP_STRINGIZE_I(text) #text
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp"
namespace boost { namespace mpl {

template<
      typename F

    , typename has_apply_ = typename aux::has_apply<F>::type

    >
struct apply_wrap0

    : F::template apply< >
{
};

template< typename F >
struct apply_wrap0< F,true_ >
    : F::apply
{
};

template<
      typename F, typename T1

    >
struct apply_wrap1

    : F::template apply<T1>
{
};

template<
      typename F, typename T1, typename T2

    >
struct apply_wrap2

    : F::template apply< T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3

    >
struct apply_wrap3

    : F::template apply< T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4

    >
struct apply_wrap4

    : F::template apply< T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5

    >
struct apply_wrap5

    : F::template apply< T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 35 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 2
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/tag.hpp" 1


#define BOOST_MPL_TAG_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/tag.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/void.hpp" 1


#define BOOST_MPL_VOID_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/void.hpp"
namespace mpl_ {





struct void_ { typedef void_ type; };

}

namespace boost { namespace mpl {

template< typename T >
struct is_void_
    : false_
{



};

template<>
struct is_void_<void_>
    : true_
{



};

template< typename T >
struct is_not_void_
    : true_
{



};

template<>
struct is_not_void_<void_>
    : false_
{



};

template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/tag.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/has_tag.hpp" 1


#define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/has_tag.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 20 "/usr/include/boost-1_41/boost/mpl/tag.hpp" 2


namespace boost { namespace mpl {

namespace aux {
template< typename T > struct tag_impl
{
    typedef typename T::tag type;
};
}

template< typename T, typename Default = void_ > struct tag

    : if_<
          aux::has_tag<T>
        , aux::tag_impl<T>
        , Default
        >::type
{
# 48 "/usr/include/boost-1_41/boost/mpl/tag.hpp"
};

}}
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp" 1


#define BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/forwarding.hpp" 1


#define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp" 2

namespace boost { namespace mpl { namespace aux {

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast1st_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
            , N2
            >
    {
# 46 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast2nd_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , N1
            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
            >
    {
# 72 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

}}}
# 26 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_eti_base.hpp" 1


#define BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_eti_base.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1


#define BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/is_msvc_eti_arg.hpp"
namespace boost { namespace mpl { namespace aux {
# 62 "/usr/include/boost-1_41/boost/mpl/aux_/is_msvc_eti_arg.hpp"
}}}
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_eti_base.hpp" 2




namespace boost { namespace mpl { namespace aux {
# 55 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_eti_base.hpp"
template< typename T > struct msvc_eti_base
    : T
{

    msvc_eti_base();

    typedef T type;
};



template<> struct msvc_eti_base<int>
{
    typedef msvc_eti_base type;
    typedef msvc_eti_base first;
    typedef msvc_eti_base second;
    typedef msvc_eti_base tag;
    enum { value = 0 };
};

}}}
# 30 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct equal_to_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct equal_to_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct equal_to_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct equal_to

    : equal_to_impl<
          typename equal_to_tag<N1>::type
        , typename equal_to_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct equal_to_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value == N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/equal_to.hpp" 2
# 25 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/greater.hpp" 1


#define BOOST_MPL_GREATER_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/greater.hpp"
#define AUX778076_OP_NAME greater
#define AUX778076_OP_TOKEN >
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/greater.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct greater_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct greater_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct greater_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct greater_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct greater_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct greater

    : greater_impl<
          typename greater_tag<N1>::type
        , typename greater_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct greater< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater< na , na > result_; typedef greater< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct greater_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value > N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/greater.hpp" 2
# 26 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp"
#define BOOST_TT_IS_POINTER_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp"
#define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED 





# 1 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp"
#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
#define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
namespace boost {
namespace type_traits {

template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};





template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };



template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };


template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };



template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
# 776 "/usr/include/boost-1_41/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
}
}
# 25 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp" 2
# 36 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 37 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp" 2

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-1_41/boost/type_traits/is_member_function_pointer.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 135 "/usr/include/boost-1_41/boost/type_traits/is_member_function_pointer.hpp" 2
# 29 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp" 2
# 39 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 40 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp" 2

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

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 115 "/usr/include/boost-1_41/boost/type_traits/is_member_pointer.hpp" 2
# 25 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/ice_and.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/detail/ice_and.hpp"
#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED 



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

}
}
# 26 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/ice_not.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/detail/ice_not.hpp"
#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED 



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

}
}
# 27 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 2
# 41 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 42 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 2

namespace boost {





namespace detail {

template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};

#define TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(helper,sp,result) template< typename T > struct helper<sp> { BOOST_STATIC_CONSTANT(bool, value = result); };






template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };

#undef TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC

template< typename T >
struct is_pointer_impl
{
# 80 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp"
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
# 89 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp"
};

}

template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
# 158 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 161 "/usr/include/boost-1_41/boost/type_traits/is_pointer.hpp" 2
# 30 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2

# 1 "/usr/include/boost-1_41/boost/serialization/tracking_enum.hpp" 1

#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP 
# 19 "/usr/include/boost-1_41/boost/serialization/tracking_enum.hpp"
namespace boost {
namespace serialization {






enum tracking_type
{

    track_never = 0,


    track_selectively = 1,

    track_always = 2
};

}
}
# 32 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/type_info_implementation.hpp" 1

#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP 
# 27 "/usr/include/boost-1_41/boost/serialization/type_info_implementation.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/traits.hpp" 1

#define BOOST_SERIALIZATION_TRAITS_HPP 
# 35 "/usr/include/boost-1_41/boost/serialization/traits.hpp"
namespace boost {
namespace serialization {


struct basic_traits {};

template <class T>
struct extended_type_info_impl;

template<
    class T,
    int Level,
    int Tracking,
    unsigned int Version = 0,
    class ETII = extended_type_info_impl< T >,
    class Wrapper = mpl::false_
>
struct traits : public basic_traits {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Version == 0 || Level >= object_class_info) == 0 ? false : true) >)> boost_static_assert_typedef_53;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Tracking == track_never || Level >= object_serializable) == 0 ? false : true) >)> boost_static_assert_typedef_54;
    typedef typename mpl::int_<Level> level;
    typedef typename mpl::int_<Tracking> tracking;
    typedef typename mpl::int_<Version> version;
    typedef ETII type_info_implementation;
    typedef Wrapper is_wrapper;
};

}
}
# 28 "/usr/include/boost-1_41/boost/serialization/type_info_implementation.hpp" 2

namespace boost {
namespace serialization {



template<class T>
struct type_info_implementation {
    template<class U>
    struct traits_class_typeinfo_implementation {
      typedef typename U::type_info_implementation::type type;
    };


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_typeinfo_implementation<T>,

            mpl::identity<
                typename extended_type_info_impl<T>::type
            >
        >::type type;
};

}
}
# 70 "/usr/include/boost-1_41/boost/serialization/type_info_implementation.hpp"
#define BOOST_CLASS_TYPE_INFO(T,ETI) namespace boost { namespace serialization { template<> struct type_info_implementation< T > { typedef ETI type; }; template<> struct type_info_implementation< const T > { typedef ETI type; }; } }
# 33 "/usr/include/boost-1_41/boost/serialization/tracking.hpp" 2

namespace boost {
namespace serialization {

struct basic_traits;


template<class T>
struct tracking_level_impl {
    template<class U>
    struct traits_class_tracking {
        typedef typename U::tracking type;
    };
    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_tracking<T>,

        typename mpl::eval_if<
            is_pointer<T>,

            mpl::int_<track_never>,

        typename mpl::eval_if<

            typename mpl::equal_to<
                implementation_level<T>,
                mpl::int_<primitive_type>
            >,

            mpl::int_<track_never>,

            mpl::int_<track_selectively>
    > > >::type type;
    static const int value = type::value;
};

template<class T>
struct tracking_level :
    public tracking_level_impl<const T>
{
};

template<class T, enum tracking_type L>
inline bool operator>=(tracking_level<T> t, enum tracking_type l)
{
    return t.value >= (int)l;
}

}
}
# 95 "/usr/include/boost-1_41/boost/serialization/tracking.hpp"
#define BOOST_CLASS_TRACKING(T,E) namespace boost { namespace serialization { template<> struct tracking_level< T > { typedef mpl::integral_c_tag tag; typedef mpl::int_< E> type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); BOOST_STATIC_ASSERT(( mpl::greater< implementation_level< T >, mpl::int_<primitive_type> >::value )); }; }}
# 33 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/split_member.hpp" 1

#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP 
# 23 "/usr/include/boost-1_41/boost/serialization/split_member.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/access.hpp" 1

#define BOOST_SERIALIZATION_ACCESS_HPP 
# 21 "/usr/include/boost-1_41/boost/serialization/access.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/pfto.hpp" 1

#define BOOST_SERIALIZATION_PFTO_HPP 
# 35 "/usr/include/boost-1_41/boost/serialization/pfto.hpp"
#define BOOST_PFTO 







namespace boost {
namespace serialization {

template<class T>
struct pfto_wrapper {
    const T & t;
    operator const T & (){
        return t;
    }
    pfto_wrapper (const T & rhs) : t(rhs) {}
};

template<class T>
pfto_wrapper<T> make_pfto_wrapper(const T & t, int){
    return pfto_wrapper<T>(t);
}

template<class T>
pfto_wrapper<T> make_pfto_wrapper(const pfto_wrapper<T> & t, int){
    return t;
}

}
}







#define BOOST_PFTO_WRAPPER(T) T
#define BOOST_MAKE_PFTO_WRAPPER(t) t
# 22 "/usr/include/boost-1_41/boost/serialization/access.hpp" 2

namespace boost {

namespace archive {
namespace detail {
    template<class Archive, class T>
    class iserializer;
    template<class Archive, class T>
    class oserializer;
}
}

namespace serialization {


template<class Archive, class T>
inline void serialize_adl(Archive &, T &, const unsigned int);
namespace detail {
    template<class Archive, class T>
    struct member_saver;
    template<class Archive, class T>
    struct member_loader;
}






class access {
public:




    template<class Archive, class T>
    friend struct detail::member_saver;
    template<class Archive, class T>
    friend struct detail::member_loader;
    template<class Archive, class T>
    friend class archive::detail::iserializer;
    template<class Archive, class T>
    friend class archive::detail::oserializer;
    template<class Archive, class T>
    friend inline void serialize(
        Archive & ar,
        T & t,
        const unsigned int file_version
    );
    template<class Archive, class T>
    friend inline void save_construct_data(
        Archive & ar,
        const T * t,
        const unsigned int file_version
    );
    template<class Archive, class T>
    friend inline void load_construct_data(
        Archive & ar,
        T * t,
        const unsigned int file_version
    );



    template<class Archive, class T>
    static void member_save(
        Archive & ar,

        T & t,
        const unsigned int file_version
    ){
        t.save(ar, file_version);
    }
    template<class Archive, class T>
    static void member_load(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){
        t.load(ar, file_version);
    }
    template<class Archive, class T>
    static void serialize(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){
        t.serialize(ar, file_version);
    }
    template<class T>
    static void destroy( const T * t)
    {


        delete const_cast<T *>(t);
    }
    template<class T>
    static void construct(T * t){



        ::new(t)T;
    }
    template<class T, class U>
    static T & cast_reference(U & u){
        return static_cast<T &>(u);
    }
    template<class T, class U>
    static T * cast_pointer(U * u){
        return static_cast<T *>(u);
    }
};

}
}
# 24 "/usr/include/boost-1_41/boost/serialization/split_member.hpp" 2

namespace boost {
namespace archive {
    namespace detail {
        template<class Archive> class interface_oarchive;
        template<class Archive> class interface_iarchive;
    }
}

namespace serialization {
namespace detail {

    template<class Archive, class T>
    struct member_saver {
        static void invoke(
            Archive & ar,
            const T & t,
            const unsigned int file_version
        ){
            access::member_save(ar, t, file_version);
        }
    };

    template<class Archive, class T>
    struct member_loader {
        static void invoke(
            Archive & ar,
            T & t,
            const unsigned int file_version
        ){
            access::member_load(ar, t, file_version);
        }
    };

}

template<class Archive, class T>
inline void split_member(
    Archive & ar, T & t, const unsigned int file_version
){
    typedef typename mpl::eval_if<
        typename Archive::is_saving,
        mpl::identity<detail::member_saver<Archive, T> >,
        mpl::identity<detail::member_loader<Archive, T> >
    >::type typex;
    typex::invoke(ar, t, file_version);
}

}
}


#define BOOST_SERIALIZATION_SPLIT_MEMBER() template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
# 34 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/base_object.hpp" 1

#define BOOST_SERIALIZATION_BASE_OBJECT_HPP 
# 33 "/usr/include/boost-1_41/boost/serialization/base_object.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp" 1
# 22 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp"
#define BOOST_TT_IS_CONST_HPP_INCLUDED 
# 43 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 44 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp" 2

namespace boost {
# 57 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp"
   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-1_41/boost/type_traits/is_const.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 144 "/usr/include/boost-1_41/boost/type_traits/is_const.hpp" 2
# 34 "/usr/include/boost-1_41/boost/serialization/base_object.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_polymorphic.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/is_polymorphic.hpp"
#define BOOST_TT_IS_POLYMORPHIC_HPP 







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 18 "/usr/include/boost-1_41/boost/type_traits/is_polymorphic.hpp" 2


namespace boost{
# 106 "/usr/include/boost-1_41/boost/type_traits/is_polymorphic.hpp"
template< typename T > struct is_polymorphic : ::boost::integral_constant<bool,__is_polymorphic(T)> { };



}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 113 "/usr/include/boost-1_41/boost/type_traits/is_polymorphic.hpp" 2
# 35 "/usr/include/boost-1_41/boost/serialization/base_object.hpp" 2



# 1 "/usr/include/boost-1_41/boost/serialization/force_include.hpp" 1

#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP 
# 43 "/usr/include/boost-1_41/boost/serialization/force_include.hpp"
#define BOOST_USED __attribute__ ((used))
# 54 "/usr/include/boost-1_41/boost/serialization/force_include.hpp"
#define BOOST_DLLEXPORT 
# 39 "/usr/include/boost-1_41/boost/serialization/base_object.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/void_cast_fwd.hpp" 1

#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP 
# 20 "/usr/include/boost-1_41/boost/serialization/void_cast_fwd.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_41/boost/serialization/void_cast_fwd.hpp" 2


namespace boost {
namespace serialization {
namespace void_cast_detail{
class void_caster;
}
template<class Derived, class Base>

inline const void_cast_detail::void_caster & void_cast_register(
    const Derived * dnull = __null,
    const Base * bnull = __null
) __attribute__ ((used));
}
}
# 40 "/usr/include/boost-1_41/boost/serialization/base_object.hpp" 2

namespace boost {
namespace serialization {

namespace detail
{


    template<class B, class D>
    struct base_cast
    {
        typedef typename
        mpl::if_<
            is_const<D>,
            const B,
            B
        >::type type;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_const<type>::value == is_const<D>::value) == 0 ? false : true) >)> boost_static_assert_typedef_57;
    };


    template<class Base, class Derived>
    struct base_register
    {
        struct polymorphic {
            static void const * invoke(){
                Base const * const b = 0;
                Derived const * const d = 0;
                return & void_cast_register(d, b);
            }
        };
        struct non_polymorphic {
            static void const * invoke(){
                return 0;
            }
        };
        static void const * invoke(){
            typedef typename mpl::eval_if<
                is_polymorphic<Base>,
                mpl::identity<polymorphic>,
                mpl::identity<non_polymorphic>
            >::type type;
            return type::invoke();
        }
    };

}
# 97 "/usr/include/boost-1_41/boost/serialization/base_object.hpp"
template<class Base, class Derived>
typename detail::base_cast<Base, Derived>::type &
base_object(Derived &d)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_base_and_derived<Base,Derived>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_101;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((! is_pointer<Derived>::value) == 0 ? false : true) >)> boost_static_assert_typedef_102;
    typedef typename detail::base_cast<Base, Derived>::type type;
    detail::base_register<type, Derived>::invoke();
    return access::cast_reference<type, Derived>(d);
}


}
}
# 35 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2

# 1 "/usr/include/boost-1_41/boost/serialization/wrapper.hpp" 1

#define BOOST_SERIALIZATION_WRAPPER_HPP 
# 14 "/usr/include/boost-1_41/boost/serialization/wrapper.hpp"
namespace boost { namespace serialization {







template<
    class T,
    int Level = object_serializable,
    int Tracking = track_never,
    unsigned int Version = 0,
    class ETII = extended_type_info_impl< T >
>
struct wrapper_traits :
    public traits<T,Level,Tracking,Version,ETII,mpl::true_>
{};

template<class T>
struct is_wrapper_impl :
    boost::mpl::eval_if<
      boost::is_base_and_derived<basic_traits,T>,
      boost::mpl::true_,
      boost::mpl::false_
    >::type
{};

template<class T>
struct is_wrapper {
    typedef typename is_wrapper_impl<const T>::type type;
};

}
}


#define BOOST_CLASS_IS_WRAPPER(T) namespace boost { namespace serialization { template<> struct is_wrapper_impl<const T> : boost::mpl::true_ {}; } }
# 37 "/usr/include/boost-1_41/boost/serialization/nvp.hpp" 2

namespace boost {
namespace serialization {

template<class T>
struct nvp :
    public std::pair<const char *, T *>,
    public wrapper_traits<const nvp<T> >
{
    explicit nvp(const char * name_, T & t) :


        std::pair<const char *, T *>(name_, (T*)(& t))
    {}
    nvp(const nvp & rhs) :

        std::pair<const char *, T *>(rhs.first, (T*)rhs.second)
    {}

    const char * name() const {
        return this->first;
    }
    T & value() const {
        return *(this->second);
    }

    const T & const_value() const {
        return *(this->second);
    }







    template<class Archivex>
    void save(
        Archivex & ar,
        const unsigned int
    ) const {

        ar.operator<<(const_value());
    }
    template<class Archivex>
    void load(
        Archivex & ar,
        const unsigned int
    ){

        ar.operator>>(value());
    }
    template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
};

template<class T>
inline

const

nvp<T> make_nvp(const char * name, T & t){
    return nvp<T>(name, t);
}
# 128 "/usr/include/boost-1_41/boost/serialization/nvp.hpp"
}
}



#define BOOST_SERIALIZATION_NVP(name) boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)



#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name) boost::serialization::make_nvp( BOOST_PP_STRINGIZE(name), boost::serialization::base_object<name >(*this) )
# 10 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/always.hpp" 1


#define BOOST_MPL_ALWAYS_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/always.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/arity_spec.hpp" 1


#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED 
# 43 "/usr/include/boost-1_41/boost/mpl/aux_/arity_spec.hpp"
#define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) 


#define BOOST_MPL_AUX_ARITY_SPEC(i,name) BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name)






#define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i,name) namespace aux { template< BOOST_MPL_PP_PARAMS(i,typename T) > struct template_arity< name<BOOST_MPL_PP_PARAMS(i,T)> > : int_<i> { }; }
# 20 "/usr/include/boost-1_41/boost/mpl/always.hpp" 2

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



}}
# 13 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1






#define BOOST_MPL_APPLY_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/apply.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_fwd.hpp" 1






#define BOOST_MPL_APPLY_FWD_HPP_INCLUDED 
# 30 "/usr/include/boost-1_41/boost/mpl/apply_fwd.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp"
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct apply;

template<
      typename F
    >
struct apply0;

template<
      typename F, typename T1
    >
struct apply1;

template<
      typename F, typename T1, typename T2
    >
struct apply2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5;

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 32 "/usr/include/boost-1_41/boost/mpl/apply_fwd.hpp" 2
# 23 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp" 1






#define BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 1






#define BOOST_MPL_ARG_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/arg.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/arg_fwd.hpp" 1


#define BOOST_MPL_ARG_FWD_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/arg_fwd.hpp"
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/na_assert.hpp" 1


#define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/na_assert.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/assert.hpp" 1


#define BOOST_MPL_ASSERT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/not.hpp" 1


#define BOOST_MPL_NOT_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/not.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/nested_type_wknd.hpp" 1


#define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/nested_type_wknd.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}






#define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) ::boost::mpl::aux::nested_type_wknd<T>
# 20 "/usr/include/boost-1_41/boost/mpl/not.hpp" 2



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-1_41/boost/mpl/assert.hpp" 2
# 29 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/pp_counter.hpp" 1


#define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/config/pp_counter.hpp"
#define BOOST_MPL_AUX_PP_COUNTER() __LINE__
# 30 "/usr/include/boost-1_41/boost/mpl/assert.hpp" 2





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 36 "/usr/include/boost-1_41/boost/mpl/assert.hpp" 2





#define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES 
# 56 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_AUX_ASSERT_CONSTANT(T,expr) enum { expr }





namespace mpl_ {

struct failed {};







#define AUX778076_ASSERT_ARG(x) x


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-1_41/boost/mpl/assert.hpp"
boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );

template< assert_::relations r, long x, long y > struct assert_relation {};






template< bool > struct assert_arg_pred_impl { typedef int type; };
template<> struct assert_arg_pred_impl<true> { typedef void* type; };

template< typename P > struct assert_arg_pred
{
    typedef typename P::type p_type;
    typedef typename assert_arg_pred_impl< p_type::value >::type type;
};

template< typename P > struct assert_arg_pred_not
{
    typedef typename P::type p_type;
    enum { p = !p_type::value };
    typedef typename assert_arg_pred_impl<p>::type type;
};

template< typename Pred >
failed ************ (Pred::************
      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
    );

template< typename Pred >
failed ************ (boost::mpl::not_<Pred>::************
      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
    );

template< typename Pred >
assert<false>
assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );

template< typename Pred >
assert<false>
assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
# 210 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#undef AUX778076_ASSERT_ARG

}




#define BOOST_MPL_ASSERT(pred) BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) pred)0, 1 ) ) ) )
# 241 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_ASSERT_NOT(pred) BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) ) ) )
# 259 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_ASSERT_RELATION_IMPL(counter,x,rel,y) enum { BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) }; BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( boost::mpl::assertion_failed<BOOST_PP_CAT(mpl_assert_rel_value,counter)>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg rel boost::mpl::assert_::arg ) ) , x , y >::************)) 0 ) ) )
# 299 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_ASSERT_RELATION(x,rel,y) BOOST_MPL_ASSERT_RELATION_IMPL(BOOST_MPL_AUX_PP_COUNTER(), x, rel, y)
# 350 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_ASSERT_MSG_IMPL(counter,c,msg,types_) struct msg; typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ { static boost::mpl::failed ************ (msg::************ assert_arg()) types_ { return 0; } } BOOST_PP_CAT(mpl_assert_arg,counter); BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) ) )
# 366 "/usr/include/boost-1_41/boost/mpl/assert.hpp"
#define BOOST_MPL_ASSERT_MSG(c,msg,types_) BOOST_MPL_ASSERT_MSG_IMPL( BOOST_MPL_AUX_PP_COUNTER(), c, msg, types_ )
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/na_assert.hpp" 2
#define BOOST_MPL_AUX_ASSERT_NOT_NA(x) BOOST_MPL_ASSERT_NOT((boost::mpl::is_na<type>))
# 26 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/arg_typedef.hpp" 1


#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/mpl/aux_/arg_typedef.hpp"
#define BOOST_MPL_AUX_ARG_TYPEDEF(T,name) 
# 28 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 2
# 36 "/usr/include/boost-1_41/boost/mpl/arg.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER arg.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1
# 13 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/arg.hpp"
namespace mpl_ {
template<> struct arg< -1 >
{
    static const int value = -1;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<1>
{
    static const int value = 1;
    typedef arg<2> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<2>
{
    static const int value = 2;
    typedef arg<3> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U2 type;
        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<3>
{
    static const int value = 3;
    typedef arg<4> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U3 type;
        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<4>
{
    static const int value = 4;
    typedef arg<5> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U4 type;
        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<5>
{
    static const int value = 5;
    typedef arg<6> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U5 type;
        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};



}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 38 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 2
# 25 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp" 2



#define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type;
# 42 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER placeholders.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1
# 13 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp"
namespace mpl_ {
typedef arg< -1 > _;
}
namespace boost { namespace mpl {

using ::mpl_::_;

namespace placeholders {
using mpl_::_;
}

}}



namespace mpl_ {
typedef arg<1> _1;

}
namespace boost { namespace mpl {

using ::mpl_::_1;

namespace placeholders {
using mpl_::_1;
}

}}
namespace mpl_ {
typedef arg<2> _2;

}
namespace boost { namespace mpl {

using ::mpl_::_2;

namespace placeholders {
using mpl_::_2;
}

}}
namespace mpl_ {
typedef arg<3> _3;

}
namespace boost { namespace mpl {

using ::mpl_::_3;

namespace placeholders {
using mpl_::_3;
}

}}
namespace mpl_ {
typedef arg<4> _4;

}
namespace boost { namespace mpl {

using ::mpl_::_4;

namespace placeholders {
using mpl_::_4;
}

}}
namespace mpl_ {
typedef arg<5> _5;

}
namespace boost { namespace mpl {

using ::mpl_::_5;

namespace placeholders {
using mpl_::_5;
}

}}
namespace mpl_ {
typedef arg<6> _6;

}
namespace boost { namespace mpl {

using ::mpl_::_6;

namespace placeholders {
using mpl_::_6;
}

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 44 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp" 2
# 25 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/lambda.hpp" 1


#define BOOST_MPL_LAMBDA_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/lambda.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 1






#define BOOST_MPL_BIND_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/bind.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/bind_fwd.hpp" 1






#define BOOST_MPL_BIND_FWD_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/mpl/bind_fwd.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/bind.hpp" 1


#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/bind_fwd.hpp" 2





#define BOOST_MPL_PREPROCESSED_HEADER bind_fwd.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp"
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct bind;

template<
      typename F
    >
struct bind0;

template<
      typename F, typename T1
    >
struct bind1;

template<
      typename F, typename T1, typename T2
    >
struct bind2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5;

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 33 "/usr/include/boost-1_41/boost/mpl/bind_fwd.hpp" 2
# 24 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/placeholders.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/next.hpp" 1


#define BOOST_MPL_NEXT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/next.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/next_prior.hpp" 1


#define BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/next_prior.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/common_name_wknd.hpp" 1


#define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 
# 30 "/usr/include/boost-1_41/boost/mpl/aux_/common_name_wknd.hpp"
#define BOOST_MPL_AUX_COMMON_NAME_WKND(name) 
# 18 "/usr/include/boost-1_41/boost/mpl/next_prior.hpp" 2



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-1_41/boost/mpl/next.hpp" 2
# 26 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/protect.hpp" 1


#define BOOST_MPL_PROTECT_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/protect.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/usr/include/boost-1_41/boost/mpl/protect.hpp"
template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };

namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }


}}
# 27 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 28 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 48 "/usr/include/boost-1_41/boost/mpl/bind.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER bind.hpp

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1
# 13 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/bind.hpp"
namespace boost { namespace mpl {

namespace aux {

template<
      typename T, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg
{
    typedef T type;
};

template<
      typename T
    , typename Arg
    >
struct replace_unnamed_arg
{
    typedef Arg next;
    typedef T type;
};

template<
      typename Arg
    >
struct replace_unnamed_arg< arg< -1 >, Arg >
{
    typedef typename Arg::next next;
    typedef Arg type;
};

template<
      int N, typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
{
    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
{
    typedef bind< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}

template<
      typename F
    >
struct bind0
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

     public:
        typedef typename apply_wrap0<
              f_
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind0<F>, U1, U2, U3, U4, U5
    >
{
    typedef bind0<F> f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }

template<
      typename F
    >
struct bind< F,na,na,na,na,na >
    : bind0<F>
{
};

template<
      typename F, typename T1
    >
struct bind1
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

     public:
        typedef typename apply_wrap1<
              f_
            , typename t1::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename U1, typename U2, typename U3
    , typename U4, typename U5
    >
struct resolve_bind_arg<
      bind1< F,T1 >, U1, U2, U3, U4, U5
    >
{
    typedef bind1< F,T1 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }

template<
      typename F, typename T1
    >
struct bind< F,T1,na,na,na,na >
    : bind1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct bind2
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

     public:
        typedef typename apply_wrap2<
              f_
            , typename t1::type, typename t2::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename U1, typename U2
    , typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
    >
{
    typedef bind2< F,T1,T2 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }

template<
      typename F, typename T1, typename T2
    >
struct bind< F,T1,T2,na,na,na >
    : bind2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

     public:
        typedef typename apply_wrap3<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename U1
    , typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
    >
{
    typedef bind3< F,T1,T2,T3 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind< F,T1,T2,T3,na,na >
    : bind3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

     public:
        typedef typename apply_wrap4<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
    >
{
    typedef bind4< F,T1,T2,T3,T4 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind< F,T1,T2,T3,T4,na >
    : bind4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

        typedef aux::replace_unnamed_arg< T5,n5 > r5;
        typedef typename r5::type a5;
        typedef typename r5::next n6;
        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;

     public:
        typedef typename apply_wrap5<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type, typename t5::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
    >
{
    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind
    : bind5< F,T1,T2,T3,T4,T5 >
{
};


template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
struct quote3;

template< typename T1, typename T2, typename T3 > struct if_;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< if_,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename if_<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

template<
      template< typename T1, typename T2, typename T3 > class F, typename Tag
    >
struct quote3;

template< typename T1, typename T2, typename T3 > struct eval_if;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< eval_if,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename eval_if<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 51 "/usr/include/boost-1_41/boost/mpl/bind.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/lambda.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 1






#define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/bind_fwd.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/quote.hpp" 1






#define BOOST_MPL_QUOTE_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/quote.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/has_type.hpp" 1


#define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/has_type.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 24 "/usr/include/boost-1_41/boost/mpl/quote.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/bcc.hpp" 1


#define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/mpl/quote.hpp" 2
# 44 "/usr/include/boost-1_41/boost/mpl/quote.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER quote.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/quote.hpp"
namespace boost { namespace mpl {

template< typename T, bool has_type_ >
struct quote_impl
{
    typedef typename T::type type;
};

template< typename T >
struct quote_impl< T,false >
{
    typedef T type;
};

template<
      template< typename P1 > class F
    , typename Tag = void_
    >
struct quote1
{
    template< typename U1 > struct apply

        : quote_impl<
              F<U1>
            , aux::has_type< F<U1> >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2 > class F
    , typename Tag = void_
    >
struct quote2
{
    template< typename U1, typename U2 > struct apply

        : quote_impl<
              F< U1,U2 >
            , aux::has_type< F< U1,U2 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename Tag = void_
    >
struct quote3
{
    template< typename U1, typename U2, typename U3 > struct apply

        : quote_impl<
              F< U1,U2,U3 >
            , aux::has_type< F< U1,U2,U3 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename Tag = void_
    >
struct quote4
{
    template<
          typename U1, typename U2, typename U3, typename U4
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4 >
            , aux::has_type< F< U1,U2,U3,U4 > >::value
            >

    {
    };
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename Tag = void_
    >
struct quote5
{
    template<
          typename U1, typename U2, typename U3, typename U4
        , typename U5
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4,U5 >
            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
            >

    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 46 "/usr/include/boost-1_41/boost/mpl/quote.hpp" 2
# 26 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 1
# 27 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/template_arity.hpp" 1






#define BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED 
# 42 "/usr/include/boost-1_41/boost/mpl/aux_/template_arity.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER template_arity.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp"
namespace boost { namespace mpl { namespace aux {

template< int N > struct arity_tag
{
    typedef char (&type)[N + 1];
};

template<
      int C1, int C2, int C3, int C4, int C5, int C6
    >
struct max_arity
{
    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) );



};

arity_tag<0>::type arity_helper(...);

template<
      template< typename P1 > class F
    , typename T1
    >
typename arity_tag<1>::type
arity_helper(type_wrapper< F<T1> >, arity_tag<1>);

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
typename arity_tag<2>::type
arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
typename arity_tag<3>::type
arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
typename arity_tag<4>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
typename arity_tag<5>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5, typename P6
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename T6
    >
typename arity_tag<6>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
template< typename F, int N >
struct template_arity_impl
{
    static const int value = sizeof(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-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 44 "/usr/include/boost-1_41/boost/mpl/aux_/template_arity.hpp" 2
# 30 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 2
# 43 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp"
namespace boost { namespace mpl {

namespace aux {

template<
      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
    , bool C5 = false
    >
struct lambda_or
    : true_
{
};

template<>
struct lambda_or< false,false,false,false,false >
    : false_
{
};

}

template<
      typename T
    , typename Tag
    , typename Arity
    >
struct lambda
{
    typedef false_ is_le;
    typedef T result_;
    typedef T type;
};

template<
      typename T
    >
struct is_lambda_expression
    : lambda<T>::is_le
{
};

template< int N, typename Tag >
struct lambda< arg<N>,Tag, int_< -1 > >
{
    typedef true_ is_le;
    typedef mpl::arg<N> result_;
    typedef mpl::protect<result_> type;
};

template<
      typename F
    , typename Tag
    >
struct lambda<
          bind0<F>
        , Tag
        , int_<1>
        >
{
    typedef false_ is_le;
    typedef bind0<
          F
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1
{
    typedef F<
          typename L1::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,Tag,F,L1 >
{
    typedef bind1<
          quote1< F,Tag >
        , typename L1::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1 > class F
    , typename T1
    , typename Tag
    >
struct lambda<
          F<T1>
        , Tag
        , int_<1>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef typename l1::is_le is_le1;
    typedef typename aux::lambda_or<
          is_le1::value
        >::type is_le;

    typedef aux::le_result1<
          is_le, Tag, F, l1
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1
    , typename Tag
    >
struct lambda<
          bind1< F,T1 >
        , Tag
        , int_<2>
        >
{
    typedef false_ is_le;
    typedef bind1<
          F
        , T1
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2
{
    typedef F<
          typename L1::type, typename L2::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,Tag,F,L1,L2 >
{
    typedef bind2<
          quote2< F,Tag >
        , typename L1::result_, typename L2::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    , typename Tag
    >
struct lambda<
          F< T1,T2 >
        , Tag
        , int_<2>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value
        >::type is_le;

    typedef aux::le_result2<
          is_le, Tag, F, l1, l2
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2
    , typename Tag
    >
struct lambda<
          bind2< F,T1,T2 >
        , Tag
        , int_<3>
        >
{
    typedef false_ is_le;
    typedef bind2<
          F
        , T1, T2
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,Tag,F,L1,L2,L3 >
{
    typedef bind3<
          quote3< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3 >
        , Tag
        , int_<3>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value
        >::type is_le;

    typedef aux::le_result3<
          is_le, Tag, F, l1, l2, l3
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          bind3< F,T1,T2,T3 >
        , Tag
        , int_<4>
        >
{
    typedef false_ is_le;
    typedef bind3<
          F
        , T1, T2, T3
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
{
    typedef bind4<
          quote4< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4 >
        , Tag
        , int_<4>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        >::type is_le;

    typedef aux::le_result4<
          is_le, Tag, F, l1, l2, l3, l4
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          bind4< F,T1,T2,T3,T4 >
        , Tag
        , int_<5>
        >
{
    typedef false_ is_le;
    typedef bind4<
          F
        , T1, T2, T3, T4
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
{
    typedef bind5<
          quote5< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_, typename L5::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4,T5 >
        , Tag
        , int_<5>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;
    typedef lambda< T5,Tag > l5;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;
    typedef typename l5::is_le is_le5;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        , is_le5::value
        >::type is_le;

    typedef aux::le_result5<
          is_le, Tag, F, l1, l2, l3, l4, l5
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind5< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind5<
          F
        , T1, T2, T3, T4, T5
        > result_;

    typedef result_ type;
};


template< typename T, typename Tag >
struct lambda< mpl::protect<T>,Tag, int_<1> >
{
    typedef false_ is_le;
    typedef mpl::protect<T> result_;
    typedef result_ type;
};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind< F,T1,T2,T3,T4,T5 > result_;
    typedef result_ type;
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    , typename Arity
    >
struct lambda<
          lambda< F,Tag1,Arity >
        , Tag2
        , int_<3>
        >
{
    typedef lambda< F,Tag2 > l1;
    typedef lambda< Tag1,Tag2 > l2;
    typedef typename l1::is_le is_le;
    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 45 "/usr/include/boost-1_41/boost/mpl/aux_/full_lambda.hpp" 2
# 23 "/usr/include/boost-1_41/boost/mpl/lambda.hpp" 2
# 26 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 2
# 35 "/usr/include/boost-1_41/boost/mpl/apply.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER apply.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/apply.hpp"
namespace boost { namespace mpl {

template<
      typename F
    >
struct apply0

    : apply_wrap0<
          typename lambda<F>::type

        >
{
   




};

template<
      typename F
    >
struct apply< F,na,na,na,na,na >
    : apply0<F>
{
};

template<
      typename F, typename T1
    >
struct apply1

    : apply_wrap1<
          typename lambda<F>::type
        , T1
        >
{
   




};

template<
      typename F, typename T1
    >
struct apply< F,T1,na,na,na,na >
    : apply1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct apply2

    : apply_wrap2<
          typename lambda<F>::type
        , T1, T2
        >
{
   




};

template<
      typename F, typename T1, typename T2
    >
struct apply< F,T1,T2,na,na,na >
    : apply2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3

    : apply_wrap3<
          typename lambda<F>::type
        , T1, T2, T3
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply< F,T1,T2,T3,na,na >
    : apply3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4

    : apply_wrap4<
          typename lambda<F>::type
        , T1, T2, T3, T4
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply< F,T1,T2,T3,T4,na >
    : apply4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5

    : apply_wrap5<
          typename lambda<F>::type
        , T1, T2, T3, T4, T5
        >
{
   




};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply
    : apply5< F,T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 2
# 14 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/remove_const.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/remove_const.hpp"
#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED 







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_41/boost/type_traits/remove_const.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 28 "/usr/include/boost-1_41/boost/type_traits/remove_const.hpp" 2

namespace boost {



namespace detail {

template <typename T, bool is_vol>
struct remove_const_helper
{
    typedef T type;
};

template <typename T>
struct remove_const_helper<T, true>
{
    typedef T volatile type;
};


template <typename T>
struct remove_const_impl
{
    typedef typename remove_const_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_volatile<T>::value
        >::type type;
};

}



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-1_41/boost/type_traits/remove_const.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 77 "/usr/include/boost-1_41/boost/type_traits/remove_const.hpp" 2
# 16 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2
# 1 "/usr/include/boost-1_41/boost/array.hpp" 1
# 25 "/usr/include/boost-1_41/boost/array.hpp"
#define BOOST_ARRAY_HPP 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 28 "/usr/include/boost-1_41/boost/array.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/stdexcept" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/stdexcept" 3
#define _GLIBCXX_STDEXCEPT 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/stdexcept" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/stdexcept" 3
  class logic_error : public exception
  {
    string _M_msg;

  public:

    explicit
    logic_error(const string& __arg);

    virtual
    ~logic_error() throw();



    virtual const char*
    what() const throw();
  };



  class domain_error : public logic_error
  {
  public:
    explicit domain_error(const string& __arg);
  };


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



}
# 29 "/usr/include/boost-1_41/boost/array.hpp" 2
# 1 "/usr/include/boost-1_41/boost/assert.hpp" 1
# 16 "/usr/include/boost-1_41/boost/assert.hpp"
#undef BOOST_ASSERT
# 36 "/usr/include/boost-1_41/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 36 "/usr/include/assert.h" 3 4
#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 37 "/usr/include/boost-1_41/boost/assert.hpp" 2
#define BOOST_ASSERT(expr) assert(expr)


#undef BOOST_VERIFY







#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# 30 "/usr/include/boost-1_41/boost/array.hpp" 2
# 1 "/usr/include/boost-1_41/boost/swap.hpp" 1







#define BOOST_SWAP_HPP 

# 1 "/usr/include/boost-1_41/boost/utility/swap.hpp" 1
# 10 "/usr/include/boost-1_41/boost/utility/swap.hpp"
#define BOOST_UTILITY_SWAP_HPP 
# 25 "/usr/include/boost-1_41/boost/utility/swap.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_41/boost/utility/swap.hpp" 2

namespace boost_swap_impl
{
  template<class T>
  void swap_impl(T& left, T& right)
  {
    using namespace std;
    swap(left,right);
  }

  template<class T, std::size_t N>
  void swap_impl(T (& left)[N], T (& right)[N])
  {
    for (std::size_t i = 0; i < N; ++i)
    {
      ::boost_swap_impl::swap_impl(left[i], right[i]);
    }
  }
}

namespace boost
{
  template<class T1, class T2>
  void swap(T1& left, T2& right)
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
}
# 11 "/usr/include/boost-1_41/boost/swap.hpp" 2
# 31 "/usr/include/boost-1_41/boost/array.hpp" 2


# 1 "/usr/include/boost-1_41/boost/detail/iterator.hpp" 1
# 51 "/usr/include/boost-1_41/boost/detail/iterator.hpp"
#define ITERATOR_DWA122600_HPP_ 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 1 3
# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 3
#define _GLIBCXX_ITERATOR 1

       
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 2 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
#define _GLIBCXX_ISTREAM 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
        __num_get_type;
      typedef ctype<_CharT> __ctype_type;

    protected:





      streamsize _M_gcount;

    public:
# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&))
      { return __pf(*this); }

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&))
      {
 __pf(*this);
 return *this;
      }

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&))
      {
 __pf(*this);
 return *this;
      }
# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      operator>>(bool& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long& __n)
      { return _M_extract(__n); }


      __istream_type&
      operator>>(long long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long long& __n)
      { return _M_extract(__n); }


      __istream_type&
      operator>>(float& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(double& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(long double& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 247 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 279 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      int_type
      get();
# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      get(char_type& __c);
# 320 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 364 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 393 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 404 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 428 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      ignore();

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore(streamsize __n, int_type __delim);
# 445 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      int_type
      peek();
# 463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 482 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      putback(char_type __c);
# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      unget();
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      int
      sync();
# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      pos_type
      tellg();
# 560 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      seekg(pos_type);
# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    protected:
      basic_istream()
      : _M_gcount(streamsize(0))
      { this->init(0); }

      template<typename _ValueT>
        __istream_type&
        _M_extract(_ValueT& __v);
    };


  template<>
    basic_istream<char>&
    basic_istream<char>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n, int_type __delim);


  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n, int_type __delim);
# 631 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 663 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 673 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
      operator bool() const
      { return _M_ok; }

    private:
      bool _M_ok;
    };
# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 734 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);


  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __in, char* __s);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }
# 762 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:



      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;







      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb) { }




      virtual
      ~basic_iostream() { }

    protected:
      basic_iostream()
      : __istream_type(), __ostream_type() { }
    };
# 823 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/istream.tcc" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/istream.tcc" 3
#define _ISTREAM_TCC 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/istream.tcc" 3



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

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      if (__in.good())
 {
   if (__in.tie())
     __in.tie()->flush();
   if (!__noskip && bool(__in.flags() & ios_base::skipws))
     {
       const __int_type __eof = traits_type::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       const __ctype_type& __ct = __check_facet(__in._M_ctype);
       while (!traits_type::eq_int_type(__c, __eof)
       && __ct.is(ctype_base::space,
    traits_type::to_char_type(__c)))
  __c = __sb->snextc();




       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
 }

      if (__in.good() && __err == ios_base::goodbit)
 _M_ok = true;
      else
 {
   __err |= ios_base::failbit;
   __in.setstate(__err);
 }
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_istream<_CharT, _Traits>&
      basic_istream<_CharT, _Traits>::
      _M_extract(_ValueT& __v)
      {
 sentry __cerb(*this, false);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
     try
       {
  const __num_get_type& __ng = __check_facet(this->_M_num_get);
  __ng.get(*this, 0, *this, __err, __v);
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {


      long __l;
      _M_extract(__l);
      if (!this->fail())
 {
   if (__gnu_cxx::__numeric_traits<short>::__min <= __l
       && __l <= __gnu_cxx::__numeric_traits<short>::__max)
     __n = short(__l);
   else
     this->setstate(ios_base::failbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {


      long __l;
      _M_extract(__l);
      if (!this->fail())
 {
   if (__gnu_cxx::__numeric_traits<int>::__min <= __l
       && __l <= __gnu_cxx::__numeric_traits<int>::__max)
     __n = int(__l);
   else
     this->setstate(ios_base::failbit);
 }
      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
     {
       bool __ineof;
       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
  __err |= ios_base::failbit;
       if (__ineof)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::failbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbout)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }




  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/istream.tcc" 3
       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

       if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::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 == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
       else if (traits_type::eq_int_type(__c, __delim))
  {
    if (_M_gcount
        < __gnu_cxx::__numeric_traits<streamsize>::__max)
      ++_M_gcount;
    __sb->sbumpc();
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;
      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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;
      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(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
           ios_base::in);
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {


      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(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {


      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(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::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(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __num = __in.width();
       if (__num <= 0)
  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;

       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

       const int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       int_type __c = __sb->sgetc();

       while (__extracted < __num - 1
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    *__s++ = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;



       *__s = char_type();
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename __istream_type::int_type __int_type;
      typedef ctype<_CharT> __ctype_type;

      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
      const __int_type __eof = _Traits::eof();
      __streambuf_type* __sb = __in.rdbuf();
      __int_type __c = __sb->sgetc();

      while (!_Traits::eq_int_type(__c, __eof)
      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
 __c = __sb->snextc();

       if (_Traits::eq_int_type(__c, __eof))
  __in.setstate(ios_base::eofbit);
      return __in;
    }





  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, char*);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);
  extern template istream& operator>>(istream&, unsigned char*);
  extern template istream& operator>>(istream&, signed char*);

  extern template istream& istream::_M_extract(unsigned short&);
  extern template istream& istream::_M_extract(unsigned int&);
  extern template istream& istream::_M_extract(long&);
  extern template istream& istream::_M_extract(unsigned long&);
  extern template istream& istream::_M_extract(bool&);

  extern template istream& istream::_M_extract(long long&);
  extern template istream& istream::_M_extract(unsigned long long&);

  extern template istream& istream::_M_extract(float&);
  extern template istream& istream::_M_extract(double&);
  extern template istream& istream::_M_extract(long double&);
  extern template istream& istream::_M_extract(void*&);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template wistream& operator>>(wistream&, wchar_t*);

  extern template wistream& wistream::_M_extract(unsigned short&);
  extern template wistream& wistream::_M_extract(unsigned int&);
  extern template wistream& wistream::_M_extract(long&);
  extern template wistream& wistream::_M_extract(unsigned long&);
  extern template wistream& wistream::_M_extract(bool&);

  extern template wistream& wistream::_M_extract(long long&);
  extern template wistream& wistream::_M_extract(unsigned long long&);

  extern template wistream& wistream::_M_extract(float&);
  extern template wistream& wistream::_M_extract(double&);
  extern template wistream& wistream::_M_extract(long double&);
  extern template wistream& wistream::_M_extract(void*&);

  extern template class basic_iostream<wchar_t>;



}
# 831 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/istream" 2 3
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stream_iterator.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stream_iterator.h" 3
#define _STREAM_ITERATOR_H 1

       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stream_iterator.h" 3



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


  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;
      bool _M_ok;

    public:

      istream_iterator()
      : _M_stream(0), _M_value(), _M_ok(false) {}


      istream_iterator(istream_type& __s)
      : _M_stream(&__s)
      { _M_read(); }

      istream_iterator(const istream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
        _M_ok(__obj._M_ok)
      { }

      const _Tp&
      operator*() const
      {
 ;


 return _M_value;
      }

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

      istream_iterator&
      operator++()
      {
 ;


 _M_read();
 return *this;
      }

      istream_iterator
      operator++(int)
      {
 ;


 istream_iterator __tmp = *this;
 _M_read();
 return __tmp;
      }

      bool
      _M_equal(const istream_iterator& __x) const
      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }

    private:
      void
      _M_read()
      {
 _M_ok = (_M_stream && *_M_stream) ? true : false;
 if (_M_ok)
   {
     *_M_stream >> _M_value;
     _M_ok = *_M_stream ? true : false;
   }
      }
    };


  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
    inline bool
    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return __x._M_equal(__y); }


  template <class _Tp, class _CharT, class _Traits, class _Dist>
    inline bool
    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return !__x._M_equal(__y); }
# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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) {}
# 176 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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; }
    };

}
# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iterator" 2 3
# 55 "/usr/include/boost-1_41/boost/detail/iterator.hpp" 2
# 77 "/usr/include/boost-1_41/boost/detail/iterator.hpp"
namespace boost { namespace detail {


template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;

}}
# 491 "/usr/include/boost-1_41/boost/detail/iterator.hpp"
#undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
#undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
# 34 "/usr/include/boost-1_41/boost/array.hpp" 2
# 1 "/usr/include/boost-1_41/boost/throw_exception.hpp" 1

#define BOOST_THROW_EXCEPTION_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/throw_exception.hpp"
# 1 "/usr/include/boost-1_41/boost/exception/detail/attribute_noreturn.hpp" 1






#define UUID_61531AB0680611DEADD5846855D89593 






#define BOOST_ATTRIBUTE_NORETURN __attribute__((noreturn))
# 24 "/usr/include/boost-1_41/boost/throw_exception.hpp" 2
# 36 "/usr/include/boost-1_41/boost/throw_exception.hpp"
# 1 "/usr/include/boost-1_41/boost/exception/exception.hpp" 1






#define UUID_274DA366004E11DCB1DDFE2E56D89593 

namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        class
        refcount_ptr
            {
            public:

            refcount_ptr():
                px_(0)
                {
                }

            ~refcount_ptr()
                {
                release();
                }

            refcount_ptr( refcount_ptr const & x ):
                px_(x.px_)
                {
                add_ref();
                }

            refcount_ptr &
            operator=( refcount_ptr const & x )
                {
                adopt(x.px_);
                return *this;
                }

            void
            adopt( T * px )
                {
                release();
                px_=px;
                add_ref();
                }

            T *
            get() const
                {
                return px_;
                }

            private:

            T * px_;

            void
            add_ref()
                {
                if( px_ )
                    px_->add_ref();
                }

            void
            release()
                {
                if( px_ )
                    px_->release();
                }
            };
        }



    template <class Tag,class T>
    class error_info;

    typedef error_info<struct throw_function_,char const *> throw_function;
    typedef error_info<struct throw_file_,char const *> throw_file;
    typedef error_info<struct throw_line_,int> throw_line;

    template <>
    class
    error_info<throw_function_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_file_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_line_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <class E,class Tag,class T>
    E const & operator<<( E const &, error_info<Tag,T> const & );

    class exception;

    template <class>
    class shared_ptr;

    namespace
    exception_detail
        {
        class error_info_base;
        struct type_info_;

        struct
        error_info_container
            {
            virtual char const * diagnostic_information( char const * ) const = 0;
            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
            virtual void add_ref() const = 0;
            virtual void release() const = 0;

            protected:

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

        template <class>
        struct get_info;

        template <>
        struct get_info<throw_function>;

        template <>
        struct get_info<throw_file>;

        template <>
        struct get_info<throw_line>;

        char const * get_diagnostic_information( exception const &, char const * );
        }

    class
    exception
        {
        protected:

        exception():
            throw_function_(0),
            throw_file_(0),
            throw_line_(-1)
            {
            }
# 199 "/usr/include/boost-1_41/boost/exception/exception.hpp"
        virtual ~exception() throw()

            = 0

            ;

        private:

        template <class E>
        friend
        E const &
        operator<<( E const & x, throw_function const & y )
            {
            x.throw_function_=y.v_;
            return x;
            }

        template <class E>
        friend
        E const &
        operator<<( E const & x, throw_file const & y )
            {
            x.throw_file_=y.v_;
            return x;
            }

        template <class E>
        friend
        E const &
        operator<<( E const & x, throw_line const & y )
            {
            x.throw_line_=y.v_;
            return x;
            }

        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );

        template <class E,class Tag,class T>
        friend E const & operator<<( E const &, error_info<Tag,T> const & );

        template <class>
        friend struct exception_detail::get_info;
        friend struct exception_detail::get_info<throw_function>;
        friend struct exception_detail::get_info<throw_file>;
        friend struct exception_detail::get_info<throw_line>;

        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
        mutable char const * throw_function_;
        mutable char const * throw_file_;
        mutable int throw_line_;
        };

    inline
    exception::
    ~exception() throw()
        {
        }



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

            ~error_info_injector() throw()
                {
                }
            };

        struct large_size { char c[256]; };
        large_size dispatch( exception * );

        struct small_size { };
        small_size dispatch( void * );

        template <class,int>
        struct enable_error_info_helper;

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(large_size)>
            {
            typedef T type;
            };

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(small_size)>
            {
            typedef error_info_injector<T> type;
            };

        template <class T>
        struct
        enable_error_info_return_type
            {
            typedef typename enable_error_info_helper<T,sizeof(dispatch((T*)0))>::type type;
            };
        }

    template <class T>
    inline
    typename
    exception_detail::enable_error_info_return_type<T>::type
    enable_error_info( T const & x )
        {
        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
        return rt(x);
        }



    namespace
    exception_detail
        {
        class
        clone_base
            {
            public:

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

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

        inline
        void
        copy_boost_exception( exception * a, exception const * b )
            {
            *a = *b;
            }

        inline
        void
        copy_boost_exception( void *, void const * )
            {
            }

        template <class T>
        class
        clone_impl:
            public T,
            public clone_base
            {
            public:

            explicit
            clone_impl( T const & x ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            ~clone_impl() throw()
                {
                }

            private:

            clone_base const *
            clone() const
                {
                return new clone_impl(*this);
                }

            void
            rethrow() const
                {
                throw*this;
                }
            };
        }

    template <class T>
    inline
    exception_detail::clone_impl<T>
    enable_current_exception( T const & x )
        {
        return exception_detail::clone_impl<T>(x);
        }
    }
# 37 "/usr/include/boost-1_41/boost/throw_exception.hpp" 2
# 1 "/usr/include/boost-1_41/boost/current_function.hpp" 1

#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/current_function.hpp"
namespace boost
{

namespace detail
{

inline void current_function_helper()
{



#define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
# 61 "/usr/include/boost-1_41/boost/current_function.hpp"
}

}

}
# 38 "/usr/include/boost-1_41/boost/throw_exception.hpp" 2
#define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(::boost::enable_error_info(x) << ::boost::throw_function(BOOST_CURRENT_FUNCTION) << ::boost::throw_file(__FILE__) << ::boost::throw_line((int)__LINE__))







namespace boost
{







inline void throw_exception_assert_compatibility( std::exception const & ) { }

template<class E> __attribute__((noreturn)) inline void throw_exception( E const & e )
{


    throw_exception_assert_compatibility(e);


    throw enable_current_exception(enable_error_info(e));



}



}
# 35 "/usr/include/boost-1_41/boost/array.hpp" 2






namespace boost {

    template<class T, std::size_t N>
    class array {
      public:
        T elems[N];

      public:

        typedef T value_type;
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef T& reference;
        typedef const T& const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;


        iterator begin() { return elems; }
        const_iterator begin() const { return elems; }
        iterator end() { return elems+N; }
        const_iterator end() const { return elems+N; }



        typedef std::reverse_iterator<iterator> reverse_iterator;
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
# 80 "/usr/include/boost-1_41/boost/array.hpp"
        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());
        }


        reference operator[](size_type i)
        {
            ((i < N && "out of range") ? static_cast<void> (0) : __assert_fail ("i < N && \"out of range\"", "/usr/include/boost-1_41/boost/array.hpp", 92, __PRETTY_FUNCTION__));
            return elems[i];
        }

        const_reference operator[](size_type i) const
        {
            ((i < N && "out of range") ? static_cast<void> (0) : __assert_fail ("i < N && \"out of range\"", "/usr/include/boost-1_41/boost/array.hpp", 98, __PRETTY_FUNCTION__));
            return elems[i];
        }


        reference at(size_type i) { rangecheck(i); return elems[i]; }
        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }


        reference front()
        {
            return elems[0];
        }

        const_reference front() const
        {
            return elems[0];
        }

        reference back()
        {
            return elems[N-1];
        }

        const_reference back() const
        {
            return elems[N-1];
        }


        static size_type size() { return N; }
        static bool empty() { return false; }
        static size_type max_size() { return N; }
        enum { static_size = N };


        void swap (array<T,N>& y) {
            for (size_type i = 0; i < N; ++i)
                boost::swap(elems[i],y.elems[i]);
        }


        const T* data() const { return elems; }
        T* data() { return elems; }


        T* c_array() { return elems; }


        template <typename T2>
        array<T,N>& operator= (const array<T2,N>& rhs) {
            std::copy(rhs.begin(),rhs.end(), begin());
            return *this;
        }


        void assign (const T& value)
        {
            std::fill_n(begin(),size(),value);
        }


        static void rangecheck (size_type i) {
            if (i >= size()) {
                throw std::out_of_range("array<>: index out of range");
            }
        }

    };


    template< class T >
    class array< T, 0 > {

      public:

        typedef T value_type;
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef T& reference;
        typedef const T& const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;


        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
        const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
        iterator end() { return begin(); }
        const_iterator end() const { return begin(); }



        typedef std::reverse_iterator<iterator> reverse_iterator;
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
# 204 "/usr/include/boost-1_41/boost/array.hpp"
        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());
        }


        reference operator[](size_type )
        {
            return failed_rangecheck();
        }

        const_reference operator[](size_type ) const
        {
            return failed_rangecheck();
        }


        reference at(size_type ) { return failed_rangecheck(); }
        const_reference at(size_type ) const { return failed_rangecheck(); }


        reference front()
        {
            return failed_rangecheck();
        }

        const_reference front() const
        {
            return failed_rangecheck();
        }

        reference back()
        {
            return failed_rangecheck();
        }

        const_reference back() const
        {
            return failed_rangecheck();
        }


        static size_type size() { return 0; }
        static bool empty() { return true; }
        static size_type max_size() { return 0; }
        enum { static_size = 0 };

        void swap (array<T,0>& ) {
        }


        const T* data() const { return 0; }
        T* data() { return 0; }


        T* c_array() { return 0; }


        template <typename T2>
        array<T,0>& operator= (const array<T2,0>& ) {
            return *this;
        }


        void assign (const T& ) { }


        static reference failed_rangecheck () {
                std::out_of_range e("attempt to access element of an empty array");
                boost::throw_exception(e);





                static T placeholder;
                return placeholder;
            }
    };



    template<class T, std::size_t N>
    bool operator== (const array<T,N>& x, const array<T,N>& y) {
        return std::equal(x.begin(), x.end(), y.begin());
    }
    template<class T, std::size_t N>
    bool operator< (const array<T,N>& x, const array<T,N>& y) {
        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
    }
    template<class T, std::size_t N>
    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
        return !(x==y);
    }
    template<class T, std::size_t N>
    bool operator> (const array<T,N>& x, const array<T,N>& y) {
        return y<x;
    }
    template<class T, std::size_t N>
    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
        return !(y<x);
    }
    template<class T, std::size_t N>
    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
        return !(x<y);
    }


    template<class T, std::size_t N>
    inline void swap (array<T,N>& x, array<T,N>& y) {
        x.swap(y);
    }

}
# 17 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iostream" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iostream" 3
#define _GLIBCXX_IOSTREAM 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iostream" 3





namespace std __attribute__ ((__visibility__ ("default"))) {
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_41/boost/serialization/array.hpp" 2







namespace boost { namespace serialization {
# 40 "/usr/include/boost-1_41/boost/serialization/array.hpp"
template <class Archive>
struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};


template<class T>
class array
 : public wrapper_traits<const array<T> >
{
public:
    typedef T value_type;

    array(value_type* t, std::size_t s) :
        m_t(t),
        m_element_count(s)
    {}


    template<class Archive>
    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
    {

      std::size_t c = count();
      value_type * t = address();
      while(0 < c--)
            ar & boost::serialization::make_nvp("item", *t++);
    }


    template<class Archive>
    void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
    {
      boost::serialization::split_member(ar, *this, version);
    }


    template<class Archive>
    void save(Archive &ar, const unsigned int version) const
    {
      ar.save_array(*this,version);
    }


    template<class Archive>
    void load(Archive &ar, const unsigned int version)
    {
      ar.load_array(*this,version);
    }


    template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
      typedef typename
          boost::serialization::use_array_optimization<Archive>::template apply<
                    typename remove_const<T>::type
                >::type use_optimized;
      serialize_optimized(ar,version,use_optimized());
    }

    value_type* address() const
    {
      return m_t;
    }

    std::size_t count() const
    {
      return m_element_count;
    }

private:
    value_type* m_t;
    std::size_t const m_element_count;
};

template<class T>
inline

const

array<T> make_array( T* t, std::size_t s){
    return array<T>(t, s);
}

template <class Archive, class T, std::size_t N>
void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int )
{
  ar & boost::serialization::make_nvp("elems",a.elems);
}



} }





#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) namespace boost { namespace serialization { template <> struct use_array_optimization<Archive> { template <class ValueType> struct apply : boost::mpl::apply1<Archive::use_array_optimization , BOOST_DEDUCED_TYPENAME boost::remove_const<ValueType>::type >::type {}; }; }}
# 22 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/collection_size_type.hpp" 1

#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP 






# 1 "/usr/include/boost-1_41/boost/serialization/strong_typedef.hpp" 1

#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP 
# 26 "/usr/include/boost-1_41/boost/serialization/strong_typedef.hpp"
# 1 "/usr/include/boost-1_41/boost/operators.hpp" 1
# 81 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_OPERATORS_HPP 


# 1 "/usr/include/boost-1_41/boost/iterator.hpp" 1
# 15 "/usr/include/boost-1_41/boost/iterator.hpp"
#define BOOST_ITERATOR_HPP 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 19 "/usr/include/boost-1_41/boost/iterator.hpp" 2


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

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

  template <class Category, class T, class Distance = std::ptrdiff_t,
            class Pointer = T*, class Reference = T&>
  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};

}
# 85 "/usr/include/boost-1_41/boost/operators.hpp" 2
# 95 "/usr/include/boost-1_41/boost/operators.hpp"
namespace boost {
namespace detail {

template <typename T> class empty_base {






};

}
}
# 118 "/usr/include/boost-1_41/boost/operators.hpp"
namespace boost
{







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

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

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

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


#define BOOST_OPERATOR2_LEFT(name) name ##2 ##_ ##left
# 172 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } friend T operator OP( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv OP ##= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
# 189 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct BOOST_OPERATOR2_LEFT(NAME) : B { friend T operator OP( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
# 254 "/usr/include/boost-1_41/boost/operators.hpp"
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };

#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
#undef BOOST_OPERATOR2_LEFT



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

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



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

template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
  R operator[](I n) const
  {
    return *(static_cast<const T&>(*this) + n);
  }
};






#define BOOST_BINARY_OPERATOR(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
# 352 "/usr/include/boost-1_41/boost/operators.hpp"
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };

#undef BOOST_BINARY_OPERATOR

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





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


}
# 666 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_IMPORT_TEMPLATE4(template_name) 
#define BOOST_IMPORT_TEMPLATE3(template_name) 
#define BOOST_IMPORT_TEMPLATE2(template_name) 
#define BOOST_IMPORT_TEMPLATE1(template_name) 
# 718 "/usr/include/boost-1_41/boost/operators.hpp"
namespace boost {


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




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

}



#define BOOST_OPERATOR_TEMPLATE4(template_name4) BOOST_IMPORT_TEMPLATE4(template_name4) template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
# 746 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_OPERATOR_TEMPLATE3(template_name3) BOOST_IMPORT_TEMPLATE3(template_name3) template<class T, class U, class V, class B> struct is_chained_base< ::boost::template_name3<T, U, V, B> > { typedef ::boost::detail::true_t value; };
# 755 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_OPERATOR_TEMPLATE2(template_name2) BOOST_IMPORT_TEMPLATE2(template_name2) template<class T, class U, class B> struct is_chained_base< ::boost::template_name2<T, U, B> > { typedef ::boost::detail::true_t value; };
# 764 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_OPERATOR_TEMPLATE1(template_name1) BOOST_IMPORT_TEMPLATE1(template_name1) template<class T, class B> struct is_chained_base< ::boost::template_name1<T, B> > { typedef ::boost::detail::true_t value; };
# 785 "/usr/include/boost-1_41/boost/operators.hpp"
#define BOOST_OPERATOR_TEMPLATE(template_name) template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct template_name : template_name ##2<T, U, B> {}; template<class T, class U, class B> struct template_name<T, U, B, ::boost::detail::true_t> : template_name ##1<T, U> {}; template <class T, class B> struct template_name<T, T, B, ::boost::detail::false_t> : template_name ##1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::template_name<T, U, B, O> > { typedef ::boost::detail::true_t value; }; BOOST_OPERATOR_TEMPLATE2(template_name ##2) BOOST_OPERATOR_TEMPLATE1(template_name ##1)
# 829 "/usr/include/boost-1_41/boost/operators.hpp"
namespace boost {

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

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

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

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

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

#undef BOOST_OPERATOR_TEMPLATE
#undef BOOST_OPERATOR_TEMPLATE4
#undef BOOST_OPERATOR_TEMPLATE3
#undef BOOST_OPERATOR_TEMPLATE2
#undef BOOST_OPERATOR_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE2
#undef BOOST_IMPORT_TEMPLATE3
#undef BOOST_IMPORT_TEMPLATE4



template <class T, class U>
struct operators2
    : totally_ordered2<T,U
    , integer_arithmetic2<T,U
    , bitwise2<T,U
      > > > {};


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

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



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




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

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

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

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

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

}
# 27 "/usr/include/boost-1_41/boost/serialization/strong_typedef.hpp" 2


#define BOOST_STRONG_TYPEDEF(T,D) struct D : boost::totally_ordered1< D , boost::totally_ordered2< D, T > > { T t; explicit D(const T t_) : t(t_) {}; D(){}; D(const D & t_) : t(t_.t){} D & operator=(const D & rhs) { t = rhs.t; return *this;} D & operator=(const T & rhs) { t = rhs; return *this;} operator const T & () const {return t; } operator T & () { return t; } bool operator==(const D & rhs) const { return t == rhs.t; } bool operator<(const D & rhs) const { return t < rhs.t; } };
# 10 "/usr/include/boost-1_41/boost/serialization/collection_size_type.hpp" 2


namespace boost { namespace serialization {

struct collection_size_type : boost::totally_ordered1< collection_size_type , boost::totally_ordered2< collection_size_type, std::size_t > > { std::size_t t; explicit collection_size_type(const std::size_t t_) : t(t_) {}; collection_size_type(){}; collection_size_type(const collection_size_type & t_) : t(t_.t){} collection_size_type & operator=(const collection_size_type & rhs) { t = rhs.t; return *this;} collection_size_type & operator=(const std::size_t & rhs) { t = rhs; return *this;} operator const std::size_t & () const {return t; } operator std::size_t & () { return t; } bool operator==(const collection_size_type & rhs) const { return t == rhs.t; } bool operator<(const collection_size_type & rhs) const { return t < rhs.t; } };

} }

namespace boost { namespace serialization { template <> struct implementation_level_impl< const boost::serialization::collection_size_type > { typedef mpl::integral_c_tag tag; typedef mpl::int_< primitive_type > type; static const int value = implementation_level_impl::type::value; }; } }
# 23 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 2


# 1 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
#define _BOOST_UBLAS_EXCEPTION_ 
# 25 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
#define _BOOST_UBLAS_CONFIG_ 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 1 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3
       
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 2 3
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 18 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 3
#define _GLIBCXX_NUMERIC_LIMITS 1

       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 3
# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 3
#define __glibcxx_integral_traps true
# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 3
#define __glibcxx_float_has_denorm_loss false


#define __glibcxx_float_traps false


#define __glibcxx_float_tinyness_before false







#define __glibcxx_double_has_denorm_loss false


#define __glibcxx_double_traps false


#define __glibcxx_double_tinyness_before false







#define __glibcxx_long_double_has_denorm_loss false


#define __glibcxx_long_double_traps false


#define __glibcxx_long_double_tinyness_before false




#define __glibcxx_signed(T) ((T)(-1) < 0)

#define __glibcxx_min(T) (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)


#define __glibcxx_max(T) (__glibcxx_signed (T) ? (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)



#define __glibcxx_digits(T) (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))



#define __glibcxx_digits10(T) (__glibcxx_digits (T) * 643 / 2136)



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






  enum float_round_style
  {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
  };







  enum float_denorm_style
  {

    denorm_indeterminate = -1,

    denorm_absent = 0,

    denorm_present = 1
  };
# 188 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
  };
# 277 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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)) - 1) << 1) + 1) : ~(char)0); }

      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 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)) - 1) << 1) + 1) : ~(wchar_t)0); }

      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 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;
    };
# 669 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/limits" 3
  template<>
    struct numeric_limits<short>
    {
      static const bool is_specialized = true;

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

      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 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) ? 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;
    };

#undef __glibcxx_float_has_denorm_loss
#undef __glibcxx_float_traps
#undef __glibcxx_float_tinyness_before


  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(1) ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static double infinity() throw()
      { return __builtin_huge_val(); }
      static double quiet_NaN() throw()
      { return __builtin_nan (""); }
      static double signaling_NaN() throw()
      { return __builtin_nans (""); }
      static double denorm_min() throw()
      { return 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;
    };

#undef __glibcxx_double_has_denorm_loss
#undef __glibcxx_double_traps
#undef __glibcxx_double_tinyness_before


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

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

      static const int digits = 64;
      static const int digits10 = 18;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static long double epsilon() throw()
      { return 1.08420217248550443401e-19L; }
      static long double round_error() throw()
      { return 0.5L; }

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

      static const bool has_infinity = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static const bool has_denorm_loss
 = false;

      static long double infinity() throw()
      { return __builtin_huge_vall (); }
      static long double quiet_NaN() throw()
      { return __builtin_nanl (""); }
      static long double signaling_NaN() throw()
      { return __builtin_nansl (""); }
      static long double denorm_min() throw()
      { return 3.64519953188247460253e-4951L; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };

#undef __glibcxx_long_double_has_denorm_loss
#undef __glibcxx_long_double_traps
#undef __glibcxx_long_double_tinyness_before

}

#undef __glibcxx_signed
#undef __glibcxx_min
#undef __glibcxx_max
#undef __glibcxx_digits
#undef __glibcxx_digits10
# 20 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2



# 1 "/usr/include/boost-1_41/boost/noncopyable.hpp" 1
# 10 "/usr/include/boost-1_41/boost/noncopyable.hpp"
#define BOOST_NONCOPYABLE_HPP_INCLUDED 

namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
   protected:
      noncopyable() {}
      ~noncopyable() {}
   private:
      noncopyable( const noncopyable& );
      const noncopyable& operator=( const noncopyable& );
  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 24 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/and.hpp" 1


#define BOOST_MPL_AND_HPP_INCLUDED 
# 41 "/usr/include/boost-1_41/boost/mpl/and.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER and.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/and.hpp"
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct and_impl
    : false_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct and_impl< true,T1,T2,T3,T4 >
    : and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , true_
        >
{
};

template<>
struct and_impl<
          true
        , true_, true_, true_, true_
        >
    : true_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = true_, typename T4 = true_, typename T5 = true_
    >
struct and_

    : aux::and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 43 "/usr/include/boost-1_41/boost/mpl/and.hpp" 2
# 26 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 1
# 13 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp"
#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED 



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/yes_no_type.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/detail/yes_no_type.hpp"
#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 

namespace boost {
namespace type_traits {

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

}
}
# 18 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/add_reference.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/add_reference.hpp"
#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED 






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 18 "/usr/include/boost-1_41/boost/type_traits/add_reference.hpp" 2

namespace boost {

namespace detail {
# 55 "/usr/include/boost-1_41/boost/type_traits/add_reference.hpp"
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-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 88 "/usr/include/boost-1_41/boost/type_traits/add_reference.hpp" 2
# 21 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/ice.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/ice.hpp"
#define BOOST_TT_ICE_HPP_INCLUDED 





# 1 "/usr/include/boost-1_41/boost/type_traits/detail/ice_eq.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/detail/ice_eq.hpp"
#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED 



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-1_41/boost/type_traits/ice.hpp" 2
# 22 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/is_abstract.hpp" 1

#define BOOST_TT_IS_ABSTRACT_CLASS_HPP 
# 62 "/usr/include/boost-1_41/boost/type_traits/is_abstract.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 63 "/usr/include/boost-1_41/boost/type_traits/is_abstract.hpp" 2


namespace boost {
namespace detail{


template <class T>
struct is_abstract_imp
{
   static const bool value = __is_abstract(T);
};
# 141 "/usr/include/boost-1_41/boost/type_traits/is_abstract.hpp"
}


template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };




}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 152 "/usr/include/boost-1_41/boost/type_traits/is_abstract.hpp" 2
# 26 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2
# 36 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 37 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2

namespace boost {
# 52 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp"
namespace detail {
# 119 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp"
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(T&);
};

template <typename T> struct checker
{
    static boost::type_traits::no_type _m_check(any_conversion ...);
    static boost::type_traits::yes_type _m_check(T, int);
};

template <typename From, typename To>
struct is_convertible_basic_impl
{
    static 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-1_41/boost/type_traits/is_convertible.hpp"
template <typename From, typename To>
struct is_convertible_impl
{
    typedef typename add_reference<From>::type ref_type;
    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value);
# 306 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp"
};


template <bool trivial1, bool trivial2, bool abstract_target>
struct is_convertible_impl_select
{
   template <class From, class To>
   struct rebind
   {
      typedef is_convertible_impl<From, To> type;
   };
};

template <>
struct is_convertible_impl_select<true, true, false>
{
   template <class From, class To>
   struct rebind
   {
      typedef true_type type;
   };
};

template <>
struct is_convertible_impl_select<false, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <>
struct is_convertible_impl_select<true, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <typename From, typename To>
struct is_convertible_impl_dispatch_base
{

   typedef is_convertible_impl_select<
      ::boost::is_arithmetic<From>::value,
      ::boost::is_arithmetic<To>::value,

      ::boost::is_abstract<To>::value



   > selector;



   typedef typename selector::template rebind<From, To> isc_binder;
   typedef typename isc_binder::type type;
};

template <typename From, typename To>
struct is_convertible_impl_dispatch
   : public is_convertible_impl_dispatch_base<From, To>::type
{};







#define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value)






#define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value)






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

#undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2
#undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1






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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 429 "/usr/include/boost-1_41/boost/type_traits/is_convertible.hpp" 2
# 28 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/remove_reference.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/remove_reference.hpp"
#define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/remove_reference.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/remove_reference.hpp" 2

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-1_41/boost/type_traits/remove_reference.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 49 "/usr/include/boost-1_41/boost/type_traits/remove_reference.hpp" 2
# 30 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2
# 58 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
#define BOOST_UBLAS_USEFUL_ARRAY_PLACEMENT_NEW 
# 200 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
#define BOOST_UBLAS_INLINE 




#define BOOST_UBLAS_CHECK_ENABLE 1




#define BOOST_UBLAS_TYPE_CHECK 1
# 222 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
template <class Dummy>
struct disable_type_check
{
    static bool value;
};
template <class Dummy>
bool disable_type_check<Dummy>::value = false;


#define BOOST_UBLAS_TYPE_CHECK_EPSILON (type_traits<real_type>::type_sqrt (std::numeric_limits<real_type>::epsilon ()))


#define BOOST_UBLAS_TYPE_CHECK_MIN (type_traits<real_type>::type_sqrt ( (std::numeric_limits<real_type>::min) ()))
# 257 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
#define BOOST_UBLAS_USE_INDEXING 
# 266 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
#define BOOST_UBLAS_BOUNDED_ARRAY_ALIGN 







#define BOOST_UBLAS_STRICT_VECTOR_SPARSE 
#define BOOST_UBLAS_STRICT_MATRIX_SPARSE 

#define BOOST_UBLAS_STRICT_HERMITIAN 
# 286 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp"
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/fwd.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/fwd.hpp"
#define BOOST_UBLAS_FWD_H 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 1 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 3
#define _GLIBCXX_MEMORY 1

       
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 3






# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_raw_storage_iter.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_raw_storage_iter.h" 3
#define _STL_RAW_STORAGE_ITERATOR_H 1

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





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

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

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

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

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

      raw_storage_iterator<_OutputIterator, _Tp>
      operator++(int)
      {
 raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
 ++_M_iter;
 return __tmp;
      }
    };

}
# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 2 3
# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
#define _STL_AUTO_PTR_H 1




namespace std __attribute__ ((__visibility__ ("default"))) {
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } ;
# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 ;
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 ;
 return _M_ptr;
      }
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 222 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } ;



  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } ;

}
# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/memory" 2 3
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/fwd.hpp" 2

namespace boost { namespace numeric { namespace ublas {


    template<class T, class ALLOC = std::allocator<T> >
    class unbounded_array;

    template<class T, std::size_t N, class ALLOC = std::allocator<T> >
    class bounded_array;

    template <class Z = std::size_t, class D = std::ptrdiff_t>
    class basic_range;
    template <class Z = std::size_t, class D = std::ptrdiff_t>
    class basic_slice;
    typedef basic_range<> range;
    typedef basic_slice<> slice;
    template<class A = unbounded_array<std::size_t> >
    class indirect_array;

    template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
    class map_std;
    template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
    class map_array;


    struct scalar_tag {};

    struct vector_tag {};
    template<class E>
    class vector_expression;
    template<class C>
    class vector_container;

    template<class E>
    class vector_reference;

    struct matrix_tag {};

    template<class E>
    class matrix_expression;
    template<class C>
    class matrix_container;

    template<class E>
    class matrix_reference;

    template<class V>
    class vector_range;
    template<class V>
    class vector_slice;
    template<class V, class IA = indirect_array<> >
    class vector_indirect;

    template<class M>
    class matrix_row;
    template<class M>
    class matrix_column;
    template<class M>
    class matrix_vector_range;
    template<class M>
    class matrix_vector_slice;
    template<class M, class IA = indirect_array<> >
    class matrix_vector_indirect;
    template<class M>
    class matrix_range;
    template<class M>
    class matrix_slice;
    template<class M, class IA = indirect_array<> >
    class matrix_indirect;

    template<class T, class A = unbounded_array<T> >
    class vector;
    template<class T, std::size_t N>
    class bounded_vector;

    template<class T = int, class ALLOC = std::allocator<T> >
    class unit_vector;
    template<class T = int, class ALLOC = std::allocator<T> >
    class zero_vector;
    template<class T = int, class ALLOC = std::allocator<T> >
    class scalar_vector;

    template<class T, std::size_t N>
    class c_vector;


    template<class T, class A = map_std<std::size_t, T> >
    class mapped_vector;
    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
    class compressed_vector;
    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
    class coordinate_vector;


    struct unknown_orientation_tag {};
    struct row_major_tag {};
    struct column_major_tag {};


    template <class Z = std::size_t, class D = std::ptrdiff_t>
    struct basic_row_major;
    typedef basic_row_major<> row_major;

    template <class Z = std::size_t, class D = std::ptrdiff_t>
    struct basic_column_major;
    typedef basic_column_major<> column_major;

    template<class T, class L = row_major, class A = unbounded_array<T> >
    class matrix;
    template<class T, std::size_t M, std::size_t N, class L = row_major>
    class bounded_matrix;

    template<class T = int, class ALLOC = std::allocator<T> >
    class identity_matrix;
    template<class T = int, class ALLOC = std::allocator<T> >
    class zero_matrix;
    template<class T = int, class ALLOC = std::allocator<T> >
    class scalar_matrix;

    template<class T, std::size_t M, std::size_t N>
    class c_matrix;

    template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
    class vector_of_vector;

    template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
    class generalized_vector_of_vector;


    struct lower_tag {};
    struct upper_tag {};
    struct unit_lower_tag : public lower_tag {};
    struct unit_upper_tag : public upper_tag {};
    struct strict_lower_tag : public lower_tag {};
    struct strict_upper_tag : public upper_tag {};


    template <class Z = std::size_t>
    struct basic_full;
    typedef basic_full<> full;

    template <class Z = std::size_t>
    struct basic_lower;
    typedef basic_lower<> lower;

    template <class Z = std::size_t>
    struct basic_upper;
    typedef basic_upper<> upper;

    template <class Z = std::size_t>
    struct basic_unit_lower;
    typedef basic_unit_lower<> unit_lower;

    template <class Z = std::size_t>
    struct basic_unit_upper;
    typedef basic_unit_upper<> unit_upper;

    template <class Z = std::size_t>
    struct basic_strict_lower;
    typedef basic_strict_lower<> strict_lower;

    template <class Z = std::size_t>
    struct basic_strict_upper;
    typedef basic_strict_upper<> strict_upper;


    template<class T, class L = row_major, class A = unbounded_array<T> >
    class banded_matrix;
    template<class T, class L = row_major, class A = unbounded_array<T> >
    class diagonal_matrix;

    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
    class triangular_matrix;
    template<class M, class TRI = lower>
    class triangular_adaptor;

    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
    class symmetric_matrix;
    template<class M, class TRI = lower>
    class symmetric_adaptor;

    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
    class hermitian_matrix;
    template<class M, class TRI = lower>
    class hermitian_adaptor;


    template<class T, class L = row_major, class A = map_std<std::size_t, T> >
    class mapped_matrix;
    template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
    class mapped_vector_of_mapped_vector;
    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
    class compressed_matrix;
    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
    class coordinate_matrix;

}}}
# 287 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/definitions.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/definitions.hpp"
#define _BOOST_UBLAS_DEFINITIONS_ 


namespace boost { namespace numeric { namespace ublas {

    namespace detail {




        template <class T> inline
        void ignore_unused_variable_warning(const T&) {}
    }



    namespace nonassignable_
    {
        class nonassignable {
        protected:
            nonassignable () {}
            ~nonassignable () {}
        private:
            const nonassignable& operator= (const nonassignable &);
        };
    }
    typedef nonassignable_::nonassignable nonassignable;




    template<class C>
    class noalias_proxy:
        private nonassignable {
    public:
        typedef typename C::closure_type closure_type;

       
        noalias_proxy (C& lval):
            nonassignable (), lval_ (lval) {}
       
        noalias_proxy (const noalias_proxy& p):
            nonassignable (), lval_ (p.lval_) {}

        template <class E>
       
        closure_type &operator= (const E& e) {
            lval_.assign (e);
            return lval_;
        }

        template <class E>
       
        closure_type &operator+= (const E& e) {
            lval_.plus_assign (e);
            return lval_;
        }

        template <class E>
       
        closure_type &operator-= (const E& e) {
            lval_.minus_assign (e);
            return lval_;
        }

    private:
        closure_type lval_;
    };



    template <class C>
   
    noalias_proxy<C> noalias (C& lvalue) {
        return noalias_proxy<C> (lvalue);
    }
    template <class C>
   
    noalias_proxy<const C> noalias (const C& lvalue) {
        return noalias_proxy<const C> (lvalue);
    }



    template <class C>
   
    C& safe (C& lvalue) {
        return lvalue;
    }
    template <class C>
   
    const C& safe (const C& lvalue) {
        return lvalue;
    }



    namespace dimension {


        template<unsigned dimension>
        struct dimension_properties {};

        template<>
        struct dimension_properties<1> {
            template <class E>
            static
            typename E::size_type size (const vector_expression<E> &e) {
                return e ().size ();
            }
            template <class E>
            static
            typename E::size_type size (const matrix_expression<E> &e) {
                return e ().size1 ();
            }

            template <class V>
            static
            typename V::size_type index (const typename V::iterator &i) {
                return i.index ();
            }
            template <class M>
            static
            typename M::size_type index (const typename M::iterator1 &i) {
                return i.index1 ();
            }
            template <class M>
            static
            typename M::size_type index (const typename M::iterator2 &i) {
                return i.index1 ();
            }
        };
        template<>
        struct dimension_properties<2> {
            template <class E>
            static
            typename E::size_type size (const vector_expression<E> &) {
                return 1;
            }
            template <class E>
            static
            typename E::size_type size (const matrix_expression<E> &e) {
                return e ().size2 ();
            }
            template <class V>
            static
            typename V::size_type index (const typename V::iterator &) {
                return 1;
            }
            template <class M>
            static
            typename M::size_type index (const typename M::iterator1 &i) {
                return i.index2 ();
            }
            template <class M>
            static
            typename M::size_type index (const typename M::iterator2 &i) {
                return i.index2 ();
            }
        };

        template<unsigned dimension, class E>
       
        typename E::size_type size (const E& e) {
            return dimension_properties<dimension>::size (e);
        }

        template<unsigned dimension, class I>
       
        typename I::container_type::size_type
        index (const I& i) {
            typedef typename I::container_type container_type;
            return dimension_properties<dimension>::template index<container_type> (i);
        }



        template<class V>
        typename V::size_type num_elements (const V &v) {
            return v.size ();
        }
        template<class M>
        typename M::size_type num_rows (const M &m) {
            return m.size1 ();
        }
        template<class M>
        typename M::size_type num_columns (const M &m) {
            return m.size2 ();
        }
        template<class MV>
        typename MV::size_type num_non_zeros (const MV &mv) {
            return mv.non_zeros ();
        }
    }


}}}
# 288 "/usr/include/boost-1_41/boost/numeric/ublas/detail/config.hpp" 2
# 26 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp" 2

namespace boost { namespace numeric { namespace ublas {

    struct divide_by_zero


        : public std::runtime_error {
        explicit divide_by_zero (const char *s = "divide by zero") :
            std::runtime_error (s) {}
        void raise () {
            throw *this;
        }
# 48 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct internal_logic


        : public std::logic_error {
        explicit internal_logic (const char *s = "internal logic") :
            std::logic_error (s) {}
        void raise () {
            throw *this;
        }
# 69 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct external_logic


        : public std::logic_error {
        explicit external_logic (const char *s = "external logic") :
            std::logic_error (s) {}



        void raise () {
            throw *this;
        }
# 93 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct bad_argument


        : public std::invalid_argument {
        explicit bad_argument (const char *s = "bad argument") :
            std::invalid_argument (s) {}
        void raise () {
            throw *this;
        }
# 114 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct bad_size


        : public std::domain_error {
        explicit bad_size (const char *s = "bad size") :
            std::domain_error (s) {}
        void raise () {
            throw *this;
        }
# 135 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct bad_index


        : public std::out_of_range {
        explicit bad_index (const char *s = "bad index") :
            std::out_of_range (s) {}
        void raise () {
            throw *this;
        }
# 156 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct singular


        : public std::runtime_error {
        explicit singular (const char *s = "singular") :
            std::runtime_error (s) {}
        void raise () {
            throw *this;
        }
# 177 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };

    struct non_real


        : public std::domain_error {
        explicit non_real (const char *s = "exception: non real") :
            std::domain_error (s) {}
        void raise () {
            throw *this;
        }
# 198 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    };
# 215 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
#define BOOST_UBLAS_CHECK_FALSE(e) std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; e.raise ();


#define BOOST_UBLAS_CHECK(expression,e) if (! (expression)) { std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; std::cerr << #expression << std::endl; e.raise (); }





#define BOOST_UBLAS_CHECK_EX(expression,file,line,e) if (! (expression)) { std::cerr << "Check failed in file " << (file) << " at line " << (line) << ":" << std::endl; std::cerr << #expression << std::endl; e.raise (); }
# 267 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
    template<class T1, class T2>
   



    T1 same_impl_ex (const T1 &size1, const T2 &size2, const char *file, int line) {
        if (! (size1 == size2)) { std::cerr << "Check failed in file " << (file) << " at line " << (line) << ":" << std::endl; std::cerr << "size1 == size2" << std::endl; bad_argument ().raise (); };
        return (size1 < size2)?(size1):(size2);
    }
    template<class T>
   
    T same_impl_ex (const T &size1, const T &size2, const char *file, int line) {
        if (! (size1 == size2)) { std::cerr << "Check failed in file " << (file) << " at line " << (line) << ":" << std::endl; std::cerr << "size1 == size2" << std::endl; bad_argument ().raise (); };
        return (std::min) (size1, size2);
    }
#define BOOST_UBLAS_SAME(size1,size2) same_impl_ex ((size1), (size2), __FILE__, __LINE__)
# 294 "/usr/include/boost-1_41/boost/numeric/ublas/exception.hpp"
}}}
# 26 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp"
#define _BOOST_UBLAS_TRAITS_ 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 1 3
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
#define _GLIBCXX_COMPLEX 1

       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3




# 1 "/usr/include/math.h" 1 3 4
# 26 "/usr/include/math.h" 3 4
#define _MATH_H 1



extern "C" {



# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 29 "/usr/include/bits/huge_val.h" 3 4
#define HUGE_VAL (__builtin_huge_val())
# 35 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/bits/huge_valf.h" 1 3 4
# 29 "/usr/include/bits/huge_valf.h" 3 4
#define HUGE_VALF (__builtin_huge_valf())
# 37 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 26 "/usr/include/bits/huge_vall.h" 3 4
#define HUGE_VALL (__builtin_huge_vall())
# 38 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/inf.h" 1 3 4
# 27 "/usr/include/bits/inf.h" 3 4
#define INFINITY (__builtin_inff())
# 41 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/nan.h" 1 3 4
# 29 "/usr/include/bits/nan.h" 3 4
#define NAN (__builtin_nanf (""))
# 44 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 24 "/usr/include/bits/mathdef.h" 3 4
#define _MATH_H_MATHDEF 1

# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 27 "/usr/include/bits/mathdef.h" 2 3 4




typedef float float_t;
typedef double double_t;
# 45 "/usr/include/bits/mathdef.h" 3 4
#define FP_ILOGB0 (-2147483647 - 1)
#define FP_ILOGBNAN (-2147483647 - 1)
# 48 "/usr/include/math.h" 2 3 4






#define __MATHCALL(function,suffix,args) __MATHDECL (_Mdouble_,function,suffix, args)

#define __MATHDECL(type,function,suffix,args) __MATHDECL_1(type, function,suffix, args); __MATHDECL_1(type, __CONCAT(__,function),suffix, args)


#define __MATHCALLX(function,suffix,args,attrib) __MATHDECLX (_Mdouble_,function,suffix, args, attrib)

#define __MATHDECLX(type,function,suffix,args,attrib) __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)


#define __MATHDECL_1(type,function,suffix,args) extern type __MATH_PRECNAME(function,suffix) args __THROW


#define _Mdouble_ double
#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();


extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();




extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();




extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();






extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();







extern double exp (double __x) throw (); extern double __exp (double __x) throw ();


extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();


extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();


extern double log (double __x) throw (); extern double __log (double __x) throw ();


extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();


extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();




extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();





extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();


extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();


extern double logb (double __x) throw (); extern double __logb (double __x) throw ();






extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();


extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();








extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();


extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();





extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();






extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();








extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));


extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));


extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));


extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();




extern int __isinf (double __value) throw () __attribute__ ((__const__));


extern int __finite (double __value) throw () __attribute__ ((__const__));





extern int isinf (double __value) throw () __attribute__ ((__const__));


extern int finite (double __value) throw () __attribute__ ((__const__));


extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();



extern double significand (double __x) throw (); extern double __significand (double __x) throw ();





extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));






extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnan (double __value) throw () __attribute__ ((__const__));



extern int isnan (double __value) throw () __attribute__ ((__const__));


extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();






extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();






extern double tgamma (double) throw (); extern double __tgamma (double) throw ();





extern double gamma (double) throw (); extern double __gamma (double) throw ();






extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();







extern double rint (double __x) throw (); extern double __rint (double __x) throw ();


extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));



extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();



extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();



extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();




extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();



extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();



extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));



extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();






extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();



extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();



extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();


extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();


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



extern int __fpclassify (double __value) throw ()
     __attribute__ ((__const__));


extern int __signbit (double __value) throw ()
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();








extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 72 "/usr/include/math.h" 2 3 4
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
# 84 "/usr/include/math.h" 3 4
#define _Mfloat_ float

#define _Mdouble_ _Mfloat_

#define __MATH_PRECNAME(name,r) name ##f ##r



#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();


extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();




extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();




extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();






extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();







extern float expf (float __x) throw (); extern float __expf (float __x) throw ();


extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();


extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();


extern float logf (float __x) throw (); extern float __logf (float __x) throw ();


extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();


extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();




extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();





extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();


extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();


extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();






extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();


extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();








extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();


extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();





extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();






extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();








extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));


extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));


extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));


extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();




extern int __isinff (float __value) throw () __attribute__ ((__const__));


extern int __finitef (float __value) throw () __attribute__ ((__const__));





extern int isinff (float __value) throw () __attribute__ ((__const__));


extern int finitef (float __value) throw () __attribute__ ((__const__));


extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();



extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();





extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));






extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanf (float __value) throw () __attribute__ ((__const__));



extern int isnanf (float __value) throw () __attribute__ ((__const__));


extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();






extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();






extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();





extern float gammaf (float) throw (); extern float __gammaf (float) throw ();






extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();







extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();


extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));



extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();



extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();



extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();




extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();



extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();



extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));



extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();






extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();



extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();



extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();


extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();


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



extern int __fpclassifyf (float __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf (float __value) throw ()
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();








extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 95 "/usr/include/math.h" 2 3 4
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
# 131 "/usr/include/math.h" 3 4
#define _Mlong_double_ long double

#define _Mdouble_ _Mlong_double_

#define __MATH_PRECNAME(name,r) name ##l ##r



#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();


extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();




extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();




extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();






extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();







extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();


extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();


extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();


extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();


extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();


extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();




extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();





extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();


extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();


extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();






extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();


extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();








extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();


extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();





extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();






extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();








extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));


extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));


extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();




extern int __isinfl (long double __value) throw () __attribute__ ((__const__));


extern int __finitel (long double __value) throw () __attribute__ ((__const__));





extern int isinfl (long double __value) throw () __attribute__ ((__const__));


extern int finitel (long double __value) throw () __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();



extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();





extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));






extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanl (long double __value) throw () __attribute__ ((__const__));



extern int isnanl (long double __value) throw () __attribute__ ((__const__));


extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();






extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();






extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();





extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();






extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();







extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();


extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();



extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();



extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();




extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();



extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();



extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));



extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();






extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();



extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();



extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();


extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();


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



extern int __fpclassifyl (long double __value) throw ()
     __attribute__ ((__const__));


extern int __signbitl (long double __value) throw ()
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();








extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 142 "/usr/include/math.h" 2 3 4
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME




#undef __MATHDECL_1
#undef __MATHDECL
#undef __MATHCALL




extern int signgam;
# 198 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN,
#define FP_NAN FP_NAN
    FP_INFINITE,
#define FP_INFINITE FP_INFINITE
    FP_ZERO,
#define FP_ZERO FP_ZERO
    FP_SUBNORMAL,
#define FP_SUBNORMAL FP_SUBNORMAL
    FP_NORMAL
#define FP_NORMAL FP_NORMAL
  };






#define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : sizeof (x) == sizeof (double) ? __fpclassify (x) : __fpclassifyl (x))
# 229 "/usr/include/math.h" 3 4
#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x) : sizeof (x) == sizeof (double) ? __signbit (x) : __signbitl (x))
# 241 "/usr/include/math.h" 3 4
#define isfinite(x) (sizeof (x) == sizeof (float) ? __finitef (x) : sizeof (x) == sizeof (double) ? __finite (x) : __finitel (x))







#define isnormal(x) (fpclassify (x) == FP_NORMAL)







#define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x) : sizeof (x) == sizeof (double) ? __isnan (x) : __isnanl (x))
# 269 "/usr/include/math.h" 3 4
#define isinf(x) (sizeof (x) == sizeof (float) ? __isinff (x) : sizeof (x) == sizeof (double) ? __isinf (x) : __isinfl (x))







#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2





#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)






typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




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



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


extern int matherr (struct __exception *__exc) throw ();




#define X_TLOSS 1.41484755040568800000e+16


#define DOMAIN 1
#define SING 2
#define OVERFLOW 3
#define UNDERFLOW 4
#define TLOSS 5
#define PLOSS 6


#define HUGE 3.40282347e+38F
# 357 "/usr/include/math.h" 3 4
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440






#define M_El 2.7182818284590452353602874713526625L
#define M_LOG2El 1.4426950408889634073599246810018921L
#define M_LOG10El 0.4342944819032518276511289189166051L
#define M_LN2l 0.6931471805599453094172321214581766L
#define M_LN10l 2.3025850929940456840179914546843642L
#define M_PIl 3.1415926535897932384626433832795029L
#define M_PI_2l 1.5707963267948966192313216916397514L
#define M_PI_4l 0.7853981633974483096156608458198757L
#define M_1_PIl 0.3183098861837906715377675267450287L
#define M_2_PIl 0.6366197723675813430755350534900574L
#define M_2_SQRTPIl 1.1283791670955125738961589031215452L
#define M_SQRT2l 1.4142135623730950488016887242096981L
#define M_SQRT1_2l 0.7071067811865475244008443621048490L
# 406 "/usr/include/math.h" 3 4
#define isgreater(x,y) __builtin_isgreater(x, y)
#define isgreaterequal(x,y) __builtin_isgreaterequal(x, y)
#define isless(x,y) __builtin_isless(x, y)
#define islessequal(x,y) __builtin_islessequal(x, y)
#define islessgreater(x,y) __builtin_islessgreater(x, y)
#define isunordered(u,v) __builtin_isunordered(u, v)
# 472 "/usr/include/math.h" 3 4
}
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 2 3


#define _GLIBCXX_CMATH 1


#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh

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



  template<typename _Tp>
    _Tp __cmath_power(_Tp, unsigned int);

  template<typename _Tp>
    inline _Tp
    __pow_helper(_Tp __x, int __n)
    {
      return __n < 0
        ? _Tp(1)/__cmath_power(__x, -__n)
        : __cmath_power(__x, __n);
    }

  inline double
  abs(double __x)
  { return __builtin_fabs(__x); }

  inline float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }

  using ::acos;

  inline float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline long double
  acos(long double __x)
  { return __builtin_acosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;

  inline float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline long double
  asin(long double __x)
  { return __builtin_asinl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;

  inline float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline long double
  atan(long double __x)
  { return __builtin_atanl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;

  inline float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }

  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<
    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
        && __is_arithmetic<_Up>::__value,
        _Tp>::__type, _Up>::__type
    atan2(_Tp __y, _Up __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return atan2(__type(__y), __type(__x));
    }

  using ::ceil;

  inline float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;

  inline float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline long double
  cos(long double __x)
  { return __builtin_cosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;

  inline float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;

  inline float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline long double
  exp(long double __x)
  { return __builtin_expl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;

  inline float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;

  inline float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline long double
  floor(long double __x)
  { return __builtin_floorl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;

  inline float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }

  using ::frexp;

  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;

  inline float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
  ldexp(_Tp __x, int __exp)
  { return __builtin_ldexp(__x, __exp); }

  using ::log;

  inline float
  log(float __x)
  { return __builtin_logf(__x); }

  inline long double
  log(long double __x)
  { return __builtin_logl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;

  inline float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline long double
  log10(long double __x)
  { return __builtin_log10l(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;

  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }

  using ::pow;

  inline float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }




  inline double
  pow(double __x, int __i)
  { return __builtin_powi(__x, __i); }

  inline float
  pow(float __x, int __n)
  { return __builtin_powif(__x, __n); }

  inline long double
  pow(long double __x, int __n)
  { return __builtin_powil(__x, __n); }


  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<
    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
        && __is_arithmetic<_Up>::__value,
        _Tp>::__type, _Up>::__type
    pow(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return pow(__type(__x), __type(__y));
    }

  using ::sin;

  inline float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;

  inline float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;

  inline float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;

  inline float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline long double
  tan(long double __x)
  { return __builtin_tanl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;

  inline float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
        double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }

}





#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered

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

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    fpclassify(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
      FP_SUBNORMAL, FP_ZERO, __type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isfinite(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isfinite(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isinf(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isinf(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnan(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnan(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnormal(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnormal(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    signbit(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_signbit(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreaterequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isless(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isless(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isunordered(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isunordered(__type(__f1), __type(__f2));
    }

}





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cmath.tcc" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/cmath.tcc" 3
#define _GLIBCXX_CMATH_TCC 1

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

  template<typename _Tp>
    inline _Tp
    __cmath_power(_Tp __x, unsigned int __n)
    {
      _Tp __y = __n % 2 ? __x : _Tp(1);

      while (__n >>= 1)
        {
          __x = __x * __x;
          if (__n % 2)
            __y = __y * __x;
        }

      return __y;
    }

}
# 610 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 2 3
# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3
#define _GLIBCXX_SSTREAM 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3




namespace std __attribute__ ((__visibility__ ("default"))) {
# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
      }
# 143 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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());
   }
      }
    };
# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 291 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()
      { }
# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
    };
# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()
      { }
# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
    };
# 475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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:
# 509 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 525 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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()
      { }
# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/sstream.tcc" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/sstream.tcc" 3
#define _SSTREAM_TCC 1

       
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/sstream.tcc" 3

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

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      if (this->eback() < this->gptr())
 {


   const bool __testeof = traits_type::eq_int_type(__c, __ret);
   if (!__testeof)
     {
       const bool __testeq = traits_type::eq(traits_type::
          to_char_type(__c),
          this->gptr()[-1]);
       const bool __testout = this->_M_mode & ios_base::out;
       if (__testeq || __testout)
  {
    this->gbump(-1);
    if (!__testeq)
      *this->gptr() = traits_type::to_char_type(__c);
    __ret = __c;
  }
     }
   else
     {
       this->gbump(-1);
       __ret = traits_type::not_eof(__c);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();
      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      const char_type __conv = traits_type::to_char_type(__c);
      if (!__testput)
 {
# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/sstream.tcc" 3
   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp;
   __tmp.reserve(__len);
   if (this->pbase())
     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
   __tmp.push_back(__conv);
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      else
 *this->pptr() = __conv;
      this->pbump(1);
      return __c;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin)
 {

   _M_update_egptr();

   if (this->gptr() < this->egptr())
     __ret = traits_type::to_int_type(*this->gptr());
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
      const bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);



      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !__off) && (__testin || __testout || __testboth))
 {
   _M_update_egptr();

   off_type __newoffi = __off;
   off_type __newoffo = __newoffi;
   if (__way == ios_base::cur)
     {
       __newoffi += this->gptr() - __beg;
       __newoffo += this->pptr() - __beg;
     }
   else if (__way == ios_base::end)
     __newoffo = __newoffi += this->egptr() - __beg;

   if ((__testin || __testboth)
       && __newoffi >= 0
       && this->egptr() - __beg >= __newoffi)
     {
       this->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>;



}
# 574 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/sstream" 2 3
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp> class complex;
  template<> class complex<float>;
  template<> class complex<double>;
  template<> class complex<long double>;


  template<typename _Tp> _Tp abs(const complex<_Tp>&);

  template<typename _Tp> _Tp arg(const complex<_Tp>&);

  template<typename _Tp> _Tp norm(const complex<_Tp>&);


  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);



  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);



  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);


  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
                                          const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    struct complex
    {

      typedef _Tp value_type;



      complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
      : _M_real(__r), _M_imag(__i) { }




      template<typename _Up>
        complex(const complex<_Up>& __z)
 : _M_real(__z.real()), _M_imag(__z.imag()) { }
# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
      _Tp& real()
      { return _M_real; }


      const _Tp& real() const
      { return _M_real; }


      _Tp& imag()
      { return _M_imag; }


      const _Tp& imag() const
      { return _M_imag; }




      void real(_Tp __val)
      { _M_real = __val; }

      void imag(_Tp __val)
      { _M_imag = __val; }


      complex<_Tp>& operator=(const _Tp&);



      complex<_Tp>&
      operator+=(const _Tp& __t)
      {
 _M_real += __t;
 return *this;
      }



      complex<_Tp>&
      operator-=(const _Tp& __t)
      {
 _M_real -= __t;
 return *this;
      }


      complex<_Tp>& operator*=(const _Tp&);

      complex<_Tp>& operator/=(const _Tp&);





      template<typename _Up>
        complex<_Tp>& operator=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator+=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator-=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator*=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator/=(const complex<_Up>&);

      const complex& __rep() const
      { return *this; }

    private:
      _Tp _M_real;
      _Tp _M_imag;
    };

  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator*=(const _Tp& __t)
    {
      _M_real *= __t;
      _M_imag *= __t;
      return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator/=(const _Tp& __t)
    {
      _M_real /= __t;
      _M_imag /= __t;
      return *this;
    }

  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator=(const complex<_Up>& __z)
    {
      _M_real = __z.real();
      _M_imag = __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator+=(const complex<_Up>& __z)
    {
      _M_real += __z.real();
      _M_imag += __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator-=(const complex<_Up>& __z)
    {
      _M_real -= __z.real();
      _M_imag -= __z.imag();
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator*=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
      _M_real = __r;
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    complex<_Tp>&
    complex<_Tp>::operator/=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
      const _Tp __n = std::norm(__z);
      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
      _M_real = __r / __n;
      return *this;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r(__x, -__y.imag());
      __r -= __y.real();
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r *= __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }



  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x)
    { return __x; }


  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x)
    { return complex<_Tp>(-__x.real(), -__x.imag()); }



  template<typename _Tp>
    inline bool
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }

  template<typename _Tp>
    inline bool
    operator==(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() == __y && __x.imag() == _Tp(); }

  template<typename _Tp>
    inline bool
    operator==(const _Tp& __x, const complex<_Tp>& __y)
    { return __x == __y.real() && _Tp() == __y.imag(); }




  template<typename _Tp>
    inline bool
    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }

  template<typename _Tp>
    inline bool
    operator!=(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() != __y || __x.imag() != _Tp(); }

  template<typename _Tp>
    inline bool
    operator!=(const _Tp& __x, const complex<_Tp>& __y)
    { return __x != __y.real() || _Tp() != __y.imag(); }



  template<typename _Tp, typename _CharT, class _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
    {
      _Tp __re_x, __im_x;
      _CharT __ch;
      __is >> __ch;
      if (__ch == '(')
 {
   __is >> __re_x >> __ch;
   if (__ch == ',')
     {
       __is >> __im_x >> __ch;
       if (__ch == ')')
  __x = complex<_Tp>(__re_x, __im_x);
       else
  __is.setstate(ios_base::failbit);
     }
   else if (__ch == ')')
     __x = __re_x;
   else
     __is.setstate(ios_base::failbit);
 }
      else
 {
   __is.putback(__ch);
   __is >> __re_x;
   __x = __re_x;
 }
      return __is;
    }


  template<typename _Tp, typename _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
    {
      basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
      return __os << __s.str();
    }
# 541 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline _Tp&
    real(complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    inline const _Tp&
    real(const complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    inline _Tp&
    imag(complex<_Tp>& __z)
    { return __z.imag(); }

  template<typename _Tp>
    inline const _Tp&
    imag(const complex<_Tp>& __z)
    { return __z.imag(); }



  template<typename _Tp>
    inline _Tp
    __complex_abs(const complex<_Tp>& __z)
    {
      _Tp __x = __z.real();
      _Tp __y = __z.imag();
      const _Tp __s = std::max(abs(__x), abs(__y));
      if (__s == _Tp())
        return __s;
      __x /= __s;
      __y /= __s;
      return __s * sqrt(__x * __x + __y * __y);
    }


  inline float
  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }

  inline double
  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }

  inline long double
  __complex_abs(const __complex__ long double& __z)
  { return __builtin_cabsl(__z); }

  template<typename _Tp>
    inline _Tp
    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
# 599 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline _Tp
    __complex_arg(const complex<_Tp>& __z)
    { return atan2(__z.imag(), __z.real()); }


  inline float
  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }

  inline double
  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }

  inline long double
  __complex_arg(const __complex__ long double& __z)
  { return __builtin_cargl(__z); }

  template<typename _Tp>
    inline _Tp
    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<bool>
    struct _Norm_helper
    {
      template<typename _Tp>
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
        {
          const _Tp __x = __z.real();
          const _Tp __y = __z.imag();
          return __x * __x + __y * __y;
        }
    };

  template<>
    struct _Norm_helper<true>
    {
      template<typename _Tp>
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
        {
          _Tp __res = std::abs(__z);
          return __res * __res;
        }
    };

  template<typename _Tp>
    inline _Tp
    norm(const complex<_Tp>& __z)
    {
      return _Norm_helper<__is_floating<_Tp>::__value
 && !0>::_S_do_it(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    polar(const _Tp& __rho, const _Tp& __theta)
    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }

  template<typename _Tp>
    inline complex<_Tp>
    conj(const complex<_Tp>& __z)
    { return complex<_Tp>(__z.real(), -__z.imag()); }




  template<typename _Tp>
    inline complex<_Tp>
    __complex_cos(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
    }


  inline __complex__ float
  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }

  inline __complex__ double
  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }

  inline __complex__ long double
  __complex_cos(const __complex__ long double& __z)
  { return __builtin_ccosl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_cosh(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
    }


  inline __complex__ float
  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }

  inline __complex__ double
  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }

  inline __complex__ long double
  __complex_cosh(const __complex__ long double& __z)
  { return __builtin_ccoshl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_exp(const complex<_Tp>& __z)
    { return std::polar(exp(__z.real()), __z.imag()); }


  inline __complex__ float
  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }

  inline __complex__ double
  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }

  inline __complex__ long double
  __complex_exp(const __complex__ long double& __z)
  { return __builtin_cexpl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_log(const complex<_Tp>& __z)
    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }


  inline __complex__ float
  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }

  inline __complex__ double
  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }

  inline __complex__ long double
  __complex_log(const __complex__ long double& __z)
  { return __builtin_clogl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }






  template<typename _Tp>
    inline complex<_Tp>
    log10(const complex<_Tp>& __z)
    { return std::log(__z) / log(_Tp(10.0)); }


  template<typename _Tp>
    inline complex<_Tp>
    __complex_sin(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
    }


  inline __complex__ float
  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }

  inline __complex__ double
  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }

  inline __complex__ long double
  __complex_sin(const __complex__ long double& __z)
  { return __builtin_csinl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_sinh(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
    }


  inline __complex__ float
  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }

  inline __complex__ double
  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }

  inline __complex__ long double
  __complex_sinh(const __complex__ long double& __z)
  { return __builtin_csinhl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
# 852 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    complex<_Tp>
    __complex_sqrt(const complex<_Tp>& __z)
    {
      _Tp __x = __z.real();
      _Tp __y = __z.imag();

      if (__x == _Tp())
        {
          _Tp __t = sqrt(abs(__y) / 2);
          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
        }
      else
        {
          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
          _Tp __u = __t / 2;
          return __x > _Tp()
            ? complex<_Tp>(__u, __y / __t)
            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
        }
    }


  inline __complex__ float
  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }

  inline __complex__ double
  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }

  inline __complex__ long double
  __complex_sqrt(const __complex__ long double& __z)
  { return __builtin_csqrtl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
# 896 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_tan(const complex<_Tp>& __z)
    { return std::sin(__z) / std::cos(__z); }


  inline __complex__ float
  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }

  inline __complex__ double
  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }

  inline __complex__ long double
  __complex_tan(const __complex__ long double& __z)
  { return __builtin_ctanl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
# 924 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    __complex_tanh(const complex<_Tp>& __z)
    { return std::sinh(__z) / std::cosh(__z); }


  inline __complex__ float
  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }

  inline __complex__ double
  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }

  inline __complex__ long double
  __complex_tanh(const __complex__ long double& __z)
  { return __builtin_ctanhl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
# 956 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __z, int __n)
    { return std::__pow_helper(__z, __n); }


  template<typename _Tp>
    complex<_Tp>
    pow(const complex<_Tp>& __x, const _Tp& __y)
    {




      if (__x.imag() == _Tp() && __x.real() > _Tp())
        return pow(__x.real(), __y);

      complex<_Tp> __t = std::log(__x);
      return std::polar(exp(__y * __t.real()), __y * __t.imag());
    }

  template<typename _Tp>
    inline complex<_Tp>
    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }


  inline __complex__ float
  __complex_pow(__complex__ float __x, __complex__ float __y)
  { return __builtin_cpowf(__x, __y); }

  inline __complex__ double
  __complex_pow(__complex__ double __x, __complex__ double __y)
  { return __builtin_cpow(__x, __y); }

  inline __complex__ long double
  __complex_pow(const __complex__ long double& __x,
  const __complex__ long double& __y)
  { return __builtin_cpowl(__x, __y); }

  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __complex_pow(__x.__rep(), __y.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    pow(const _Tp& __x, const complex<_Tp>& __y)
    {
      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
          __y.imag() * log(__x))
                  : std::pow(complex<_Tp>(__x), __y);
    }



  template<>
    struct complex<float>
    {
      typedef float value_type;
      typedef __complex__ float _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(float __r = 0.0f, float __i = 0.0f)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      explicit complex(const complex<double>&);
      explicit complex(const complex<long double>&);
# 1044 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
      float& real()
      { return __real__ _M_value; }

      const float& real() const
      { return __real__ _M_value; }

      float& imag()
      { return __imag__ _M_value; }

      const float& imag() const
      { return __imag__ _M_value; }




      void real(float __val)
      { __real__ _M_value = __val; }

      void imag(float __val)
      { __imag__ _M_value = __val; }

      complex<float>&
      operator=(float __f)
      {
 __real__ _M_value = __f;
 __imag__ _M_value = 0.0f;
 return *this;
      }

      complex<float>&
      operator+=(float __f)
      {
 __real__ _M_value += __f;
 return *this;
      }

      complex<float>&
      operator-=(float __f)
      {
 __real__ _M_value -= __f;
 return *this;
      }

      complex<float>&
      operator*=(float __f)
      {
 _M_value *= __f;
 return *this;
      }

      complex<float>&
      operator/=(float __f)
      {
 _M_value /= __f;
 return *this;
      }





      template<typename _Tp>
        complex<float>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<float>&
        operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<class _Tp>
        complex<float>&
        operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<double>
    {
      typedef double value_type;
      typedef __complex__ double _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(double __r = 0.0, double __i = 0.0)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      explicit complex(const complex<long double>&);
# 1190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
      double& real()
      { return __real__ _M_value; }

      const double& real() const
      { return __real__ _M_value; }

      double& imag()
      { return __imag__ _M_value; }

      const double& imag() const
      { return __imag__ _M_value; }




      void real(double __val)
      { __real__ _M_value = __val; }

      void imag(double __val)
      { __imag__ _M_value = __val; }

      complex<double>&
      operator=(double __d)
      {
 __real__ _M_value = __d;
 __imag__ _M_value = 0.0;
 return *this;
      }

      complex<double>&
      operator+=(double __d)
      {
 __real__ _M_value += __d;
 return *this;
      }

      complex<double>&
      operator-=(double __d)
      {
 __real__ _M_value -= __d;
 return *this;
      }

      complex<double>&
      operator*=(double __d)
      {
 _M_value *= __d;
 return *this;
      }

      complex<double>&
      operator/=(double __d)
      {
 _M_value /= __d;
 return *this;
      }




      template<typename _Tp>
        complex<double>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex<double>&
        operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<long double>
    {
      typedef long double value_type;
      typedef __complex__ long double _ComplexT;

      complex(_ComplexT __z) : _M_value(__z) { }

      complex(long double __r = 0.0L, long double __i = 0.0L)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = __i;
      }

      complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      complex(const complex<double>& __z)
      : _M_value(__z.__rep()) { }
# 1336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/complex" 3
      long double& real()
      { return __real__ _M_value; }

      const long double& real() const
      { return __real__ _M_value; }

      long double& imag()
      { return __imag__ _M_value; }

      const long double& imag() const
      { return __imag__ _M_value; }




      void real(long double __val)
      { __real__ _M_value = __val; }

      void imag(long double __val)
      { __imag__ _M_value = __val; }

      complex<long double>&
      operator=(long double __r)
      {
 __real__ _M_value = __r;
 __imag__ _M_value = 0.0L;
 return *this;
      }

      complex<long double>&
      operator+=(long double __r)
      {
 __real__ _M_value += __r;
 return *this;
      }

      complex<long double>&
      operator-=(long double __r)
      {
 __real__ _M_value -= __r;
 return *this;
      }

      complex<long double>&
      operator*=(long double __r)
      {
 _M_value *= __r;
 return *this;
      }

      complex<long double>&
      operator/=(long double __r)
      {
 _M_value /= __r;
 return *this;
      }




      template<typename _Tp>
        complex<long double>&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator+=(const complex<_Tp>& __z)
 {
   __real__ _M_value += __z.real();
   __imag__ _M_value += __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator-=(const complex<_Tp>& __z)
 {
   __real__ _M_value -= __z.real();
   __imag__ _M_value -= __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator*=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex<long double>&
 operator/=(const complex<_Tp>& __z)
 {
   _ComplexT __t;
   __real__ __t = __z.real();
   __imag__ __t = __z.imag();
   _M_value /= __t;
   return *this;
 }

      const _ComplexT& __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  inline
  complex<float>::complex(const complex<double>& __z)
  : _M_value(__z.__rep()) { }

  inline
  complex<float>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }

  inline
  complex<double>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }





  extern template istream& operator>>(istream&, complex<float>&);
  extern template ostream& operator<<(ostream&, const complex<float>&);
  extern template istream& operator>>(istream&, complex<double>&);
  extern template ostream& operator<<(ostream&, const complex<double>&);
  extern template istream& operator>>(istream&, complex<long double>&);
  extern template ostream& operator<<(ostream&, const complex<long double>&);


  extern template wistream& operator>>(wistream&, complex<float>&);
  extern template wostream& operator<<(wostream&, const complex<float>&);
  extern template wistream& operator>>(wistream&, complex<double>&);
  extern template wostream& operator<<(wostream&, const complex<double>&);
  extern template wistream& operator>>(wistream&, complex<long double>&);
  extern template wostream& operator<<(wostream&, const complex<long double>&);





}

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


  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, _Up>
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<_Tp, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

}
# 18 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/config/no_tr1/cmath.hpp" 1
# 14 "/usr/include/boost-1_41/boost/config/no_tr1/cmath.hpp"
#define BOOST_CONFIG_CMATH 


#define BOOST_TR1_NO_RECURSION 
#define BOOST_CONFIG_NO_CMATH_RECURSION 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
# 22 "/usr/include/boost-1_41/boost/config/no_tr1/cmath.hpp" 2


#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_CMATH_RECURSION
# 19 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 2


# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
#define _BOOST_UBLAS_ITERATOR_ 





namespace boost { namespace numeric { namespace ublas {






    template<class C>
    class container_const_reference:
        private nonassignable {
    public:
        typedef C container_type;

       
        container_const_reference ():
            c_ (0) {}
       
        container_const_reference (const container_type &c):
            c_ (&c) {}

       
        const container_type &operator () () const {
            return *c_;
        }

       
        container_const_reference &assign (const container_type *c) {
            c_ = c;
            return *this;
        }


       
        bool same_closure (const container_const_reference &cr) const {
            return c_ == cr.c_;
        }

    private:
        const container_type *c_;
    };






    template<class C>
    class container_reference:
        private nonassignable {
    public:
        typedef C container_type;

       
        container_reference ():
            c_ (0) {}
       
        container_reference (container_type &c):
            c_ (&c) {}

       
        container_type &operator () () const {
           return *c_;
        }

       
        container_reference &assign (container_type *c) {
            c_ = c;
            return *this;
        }


       
        bool same_closure (const container_reference &cr) const {
            return c_ == cr.c_;
        }

    private:
        container_type *c_;
    };
# 109 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class IC, class I, class T>
    struct forward_iterator_base:
        public std::iterator<IC, T> {
        typedef I derived_iterator_type;
        typedef T derived_value_type;


       
        derived_iterator_type operator ++ (int) {
            derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }
       
        friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }


       
        bool operator != (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return ! (*d == it);
        }
    };
# 147 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class IC, class I, class T>
    struct bidirectional_iterator_base:
        public std::iterator<IC, T> {
        typedef I derived_iterator_type;
        typedef T derived_value_type;


       
        derived_iterator_type operator ++ (int) {
            derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }
       
        friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }
       
        derived_iterator_type operator -- (int) {
            derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
            derived_iterator_type tmp (d);
            -- d;
            return tmp;
        }
       
        friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
            derived_iterator_type tmp (d);
            -- d;
            return tmp;
        }


       
        bool operator != (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return ! (*d == it);
        }
    };
# 201 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class IC, class I, class T, class D = std::ptrdiff_t>

    struct random_access_iterator_base:
        public std::iterator<IC, T> {
        typedef I derived_iterator_type;
        typedef T derived_value_type;
        typedef D derived_difference_type;
# 219 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
       
        derived_iterator_type operator ++ (int) {
            derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }
       
        friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
            derived_iterator_type tmp (d);
            ++ d;
            return tmp;
        }
       
        derived_iterator_type operator -- (int) {
            derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
            derived_iterator_type tmp (d);
            -- d;
            return tmp;
        }
       
        friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
            derived_iterator_type tmp (d);
            -- d;
            return tmp;
        }
       
        derived_iterator_type operator + (derived_difference_type n) const {
            derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
            return tmp += n;
        }
       
        friend derived_iterator_type operator + (const derived_iterator_type &d, derived_difference_type n) {
            derived_iterator_type tmp (d);
            return tmp += n;
        }
       
        friend derived_iterator_type operator + (derived_difference_type n, const derived_iterator_type &d) {
            derived_iterator_type tmp (d);
            return tmp += n;
        }
       
        derived_iterator_type operator - (derived_difference_type n) const {
            derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
            return tmp -= n;
        }
       
        friend derived_iterator_type operator - (const derived_iterator_type &d, derived_difference_type n) {
            derived_iterator_type tmp (d);
            return tmp -= n;
        }


       
        bool operator != (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return ! (*d == it);
        }
       
        bool operator <= (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return ! (it < *d);
        }
       
        bool operator >= (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return ! (*d < it);
        }
       
        bool operator > (const derived_iterator_type &it) const {
            const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
            return it < *d;
        }
    };
# 310 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template <class I>
    class reverse_iterator_base:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;


       
        reverse_iterator_base ():
            std::reverse_iterator<iterator_type> () {}
       
        reverse_iterator_base (const iterator_type &it):
            std::reverse_iterator<iterator_type> (it) {}


       
        reverse_iterator_base &operator ++ () {
            return *this = -- this->base ();
        }
       
        reverse_iterator_base operator ++ (int) {
            reverse_iterator_base tmp (*this);
            *this = -- this->base ();
            return tmp;
        }
       
        reverse_iterator_base &operator -- () {
            return *this = ++ this->base ();
        }
       
        reverse_iterator_base operator -- (int) {
            reverse_iterator_base tmp (*this);
            *this = ++ this->base ();
            return tmp;
        }
       
        reverse_iterator_base &operator += (difference_type n) {
            return *this = this->base () - n;
        }
       
        reverse_iterator_base &operator -= (difference_type n) {
            return *this = this->base () + n;
        }

       
        friend reverse_iterator_base operator + (const reverse_iterator_base &it, difference_type n) {
            reverse_iterator_base tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base operator + (difference_type n, const reverse_iterator_base &it) {
            reverse_iterator_base tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base operator - (const reverse_iterator_base &it, difference_type n) {
            reverse_iterator_base tmp (it);
            return tmp -= n;
        }
       
        friend difference_type operator - (const reverse_iterator_base &it1, const reverse_iterator_base &it2) {
            return it2.base () - it1.base ();
        }

       
        const container_type &operator () () const {
            return this->base () ();
        }

       
        size_type index () const {
            iterator_type tmp (this->base ());
            return (-- tmp).index ();
        }
    };
# 404 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template <class I>
    class reverse_iterator_base1:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;
        typedef typename I::dual_iterator_type dual_iterator_type;
        typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;


       
        reverse_iterator_base1 ():
            std::reverse_iterator<iterator_type> () {}
       
        reverse_iterator_base1 (const iterator_type &it):
            std::reverse_iterator<iterator_type> (it) {}


       
        reverse_iterator_base1 &operator ++ () {
            return *this = -- this->base ();
        }
       
        reverse_iterator_base1 operator ++ (int) {
            reverse_iterator_base1 tmp (*this);
            *this = -- this->base ();
            return tmp;
        }
       
        reverse_iterator_base1 &operator -- () {
            return *this = ++ this->base ();
        }
       
        reverse_iterator_base1 operator -- (int) {
            reverse_iterator_base1 tmp (*this);
            *this = ++ this->base ();
            return tmp;
        }
       
        reverse_iterator_base1 &operator += (difference_type n) {
            return *this = this->base () - n;
        }
       
        reverse_iterator_base1 &operator -= (difference_type n) {
            return *this = this->base () + n;
        }

       
        friend reverse_iterator_base1 operator + (const reverse_iterator_base1 &it, difference_type n) {
            reverse_iterator_base1 tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base1 operator + (difference_type n, const reverse_iterator_base1 &it) {
            reverse_iterator_base1 tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base1 operator - (const reverse_iterator_base1 &it, difference_type n) {
            reverse_iterator_base1 tmp (it);
            return tmp -= n;
        }
       
        friend difference_type operator - (const reverse_iterator_base1 &it1, const reverse_iterator_base1 &it2) {
            return it2.base () - it1.base ();
        }

       
        const container_type &operator () () const {
            return this->base () ();
        }

       
        size_type index1 () const {
            iterator_type tmp (this->base ());
            return (-- tmp).index1 ();
        }
       
        size_type index2 () const {
            iterator_type tmp (this->base ());
            return (-- tmp).index2 ();
        }

       
        dual_iterator_type begin () const {
            iterator_type tmp (this->base ());
            return (-- tmp).begin ();
        }
       
        dual_iterator_type end () const {
            iterator_type tmp (this->base ());
            return (-- tmp).end ();
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }
    };
# 526 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template <class I>
    class reverse_iterator_base2:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;
        typedef typename I::dual_iterator_type dual_iterator_type;
        typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;


       
        reverse_iterator_base2 ():
            std::reverse_iterator<iterator_type> () {}
       
        reverse_iterator_base2 (const iterator_type &it):
            std::reverse_iterator<iterator_type> (it) {}


       
        reverse_iterator_base2 &operator ++ () {
            return *this = -- this->base ();
        }
       
        reverse_iterator_base2 operator ++ (int) {
            reverse_iterator_base2 tmp (*this);
            *this = -- this->base ();
            return tmp;
        }
       
        reverse_iterator_base2 &operator -- () {
            return *this = ++ this->base ();
        }
       
        reverse_iterator_base2 operator -- (int) {
            reverse_iterator_base2 tmp (*this);
            *this = ++ this->base ();
            return tmp;
        }
       
        reverse_iterator_base2 &operator += (difference_type n) {
            return *this = this->base () - n;
        }
       
        reverse_iterator_base2 &operator -= (difference_type n) {
            return *this = this->base () + n;
        }

       
        friend reverse_iterator_base2 operator + (const reverse_iterator_base2 &it, difference_type n) {
            reverse_iterator_base2 tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base2 operator + (difference_type n, const reverse_iterator_base2 &it) {
            reverse_iterator_base2 tmp (it);
            return tmp += n;
        }
       
        friend reverse_iterator_base2 operator - (const reverse_iterator_base2 &it, difference_type n) {
            reverse_iterator_base2 tmp (it);
            return tmp -= n;
        }
       
        friend difference_type operator - (const reverse_iterator_base2 &it1, const reverse_iterator_base2 &it2) {
            return it2.base () - it1.base ();
        }

       
        const container_type &operator () () const {
            return this->base () ();
        }

       
        size_type index1 () const {
            iterator_type tmp (this->base ());
            return (-- tmp).index1 ();
        }
       
        size_type index2 () const {
            iterator_type tmp (this->base ());
            return (-- tmp).index2 ();
        }

       
        dual_iterator_type begin () const {
            iterator_type tmp (this->base ());
            return (-- tmp).begin ();
        }
       
        dual_iterator_type end () const {
            iterator_type tmp (this->base ());
            return (-- tmp).end ();
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }
    };
# 643 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_iterator:
        public container_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_iterator<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::reference reference;


       
        indexed_iterator ():
            container_reference<container_type> (), it_ () {}
       
        indexed_iterator (container_type &c, size_type it):
            container_reference<container_type> (c), it_ (it) {}


       
        indexed_iterator &operator ++ () {
            ++ it_;
            return *this;
        }
       
        indexed_iterator &operator -- () {
            -- it_;
            return *this;
        }
       
        indexed_iterator &operator += (difference_type n) {
            it_ += n;
            return *this;
        }
       
        indexed_iterator &operator -= (difference_type n) {
            it_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 689 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ - it.it_;
        }


       
        reference operator * () const {
            if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 696 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index () const {
            return it_;
        }


       
        indexed_iterator &operator = (const indexed_iterator &it) {


            container_reference<C>::assign (&it ());
            it_ = it.it_;
            return *this;
        }


       
        bool operator == (const indexed_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 723 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ == it.it_;
        }
       
        bool operator < (const indexed_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 728 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ < it.it_;
        }

    private:
        size_type it_;
    };
# 751 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_const_iterator:
        public container_const_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_const_iterator<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::const_reference reference;
        typedef indexed_iterator<container_type, iterator_category> iterator_type;


       
        indexed_const_iterator ():
            container_const_reference<container_type> (), it_ () {}
       
        indexed_const_iterator (const container_type &c, size_type it):
            container_const_reference<container_type> (c), it_ (it) {}
       
        indexed_const_iterator (const iterator_type &it):
            container_const_reference<container_type> (it ()), it_ (it.index ()) {}


       
        indexed_const_iterator &operator ++ () {
            ++ it_;
            return *this;
        }
       
        indexed_const_iterator &operator -- () {
            -- it_;
            return *this;
        }
       
        indexed_const_iterator &operator += (difference_type n) {
            it_ += n;
            return *this;
        }
       
        indexed_const_iterator &operator -= (difference_type n) {
            it_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_const_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 801 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ - it.it_;
        }


       
        reference operator * () const {
            if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 808 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index () const {
            return it_;
        }


       
        indexed_const_iterator &operator = (const indexed_const_iterator &it) {


            container_const_reference<C>::assign (&it ());
            it_ = it.it_;
            return *this;
        }


       
        bool operator == (const indexed_const_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 835 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ == it.it_;
        }
       
        bool operator < (const indexed_const_iterator &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 840 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            return it_ < it.it_;
        }

    private:
        size_type it_;

        friend class indexed_iterator<container_type, iterator_category>;
    };

    template<class C, class IC>
    class indexed_iterator2;
# 871 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_iterator1:
        public container_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_iterator1<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::reference reference;

        typedef indexed_iterator2<container_type, iterator_category> dual_iterator_type;
        typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;


       
        indexed_iterator1 ():
            container_reference<container_type> (), it1_ (), it2_ () {}
       
        indexed_iterator1 (container_type &c, size_type it1, size_type it2):
            container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}


       
        indexed_iterator1 &operator ++ () {
            ++ it1_;
            return *this;
        }
       
        indexed_iterator1 &operator -- () {
            -- it1_;
            return *this;
        }
       
        indexed_iterator1 &operator += (difference_type n) {
            it1_ += n;
            return *this;
        }
       
        indexed_iterator1 &operator -= (difference_type n) {
            it1_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 920 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 921 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ - it.it1_;
        }


       
        reference operator * () const {
            if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 928 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
            if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 929 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it1_, it2_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index1 () const {
            return it1_;
        }
       
        size_type index2 () const {
            return it2_;
        }

       
        dual_iterator_type begin () const {
            return (*this) ().find2 (1, index1 (), 0);
        }
       
        dual_iterator_type end () const {
            return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }


       
        indexed_iterator1 &operator = (const indexed_iterator1 &it) {


            container_reference<C>::assign (&it ());
            it1_ = it.it1_;
            it2_ = it.it2_;
            return *this;
        }


       
        bool operator == (const indexed_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 978 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 979 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ == it.it1_;
        }
       
        bool operator < (const indexed_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 984 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 985 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ < it.it1_;
        }

    private:
        size_type it1_;
        size_type it2_;
    };

    template<class C, class IC>
    class indexed_const_iterator2;
# 1017 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_const_iterator1:
        public container_const_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_const_iterator1<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::const_reference reference;

        typedef indexed_iterator1<container_type, iterator_category> iterator_type;
        typedef indexed_const_iterator2<container_type, iterator_category> dual_iterator_type;
        typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;


       
        indexed_const_iterator1 ():
            container_const_reference<container_type> (), it1_ (), it2_ () {}
       
        indexed_const_iterator1 (const container_type &c, size_type it1, size_type it2):
            container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
       
        indexed_const_iterator1 (const iterator_type &it):
            container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}


       
        indexed_const_iterator1 &operator ++ () {
            ++ it1_;
            return *this;
        }
       
        indexed_const_iterator1 &operator -- () {
            -- it1_;
            return *this;
        }
       
        indexed_const_iterator1 &operator += (difference_type n) {
            it1_ += n;
            return *this;
        }
       
        indexed_const_iterator1 &operator -= (difference_type n) {
            it1_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_const_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1070 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1071 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ - it.it1_;
        }


       
        reference operator * () const {
            if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1078 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
            if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1079 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it1_, it2_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index1 () const {
            return it1_;
        }
       
        size_type index2 () const {
            return it2_;
        }

       
        dual_iterator_type begin () const {
            return (*this) ().find2 (1, index1 (), 0);
        }
       
        dual_iterator_type end () const {
            return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }


       
        indexed_const_iterator1 &operator = (const indexed_const_iterator1 &it) {


            container_const_reference<C>::assign (&it ());
            it1_ = it.it1_;
            it2_ = it.it2_;
            return *this;
        }


       
        bool operator == (const indexed_const_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1128 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1129 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ == it.it1_;
        }
       
        bool operator < (const indexed_const_iterator1 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1134 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1135 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
            return it1_ < it.it1_;
        }

    private:
        size_type it1_;
        size_type it2_;

        friend class indexed_iterator1<container_type, iterator_category>;
    };
# 1162 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_iterator2:
        public container_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_iterator2<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::reference reference;

        typedef indexed_iterator1<container_type, iterator_category> dual_iterator_type;
        typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;


       
        indexed_iterator2 ():
            container_reference<container_type> (), it1_ (), it2_ () {}
       
        indexed_iterator2 (container_type &c, size_type it1, size_type it2):
            container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}


       
        indexed_iterator2 &operator ++ () {
            ++ it2_;
            return *this;
        }
       
        indexed_iterator2 &operator -- () {
            -- it2_;
            return *this;
        }
       
        indexed_iterator2 &operator += (difference_type n) {
            it2_ += n;
            return *this;
        }
       
        indexed_iterator2 &operator -= (difference_type n) {
            it2_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1211 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1212 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ - it.it2_;
        }


       
        reference operator * () const {
            if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1219 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
            if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1220 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it1_, it2_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index1 () const {
            return it1_;
        }
       
        size_type index2 () const {
            return it2_;
        }

       
        dual_iterator_type begin () const {
            return (*this) ().find1 (1, 0, index2 ());
        }
       
        dual_iterator_type end () const {
            return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }


       
        indexed_iterator2 &operator = (const indexed_iterator2 &it) {


            container_reference<C>::assign (&it ());
            it1_ = it.it1_;
            it2_ = it.it2_;
            return *this;
        }


       
        bool operator == (const indexed_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1269 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1270 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ == it.it2_;
        }
       
        bool operator < (const indexed_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1275 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1276 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ < it.it2_;
        }

    private:
        size_type it1_;
        size_type it2_;
    };
# 1305 "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp"
    template<class C, class IC>
    class indexed_const_iterator2:
        public container_const_reference<C>,
        public random_access_iterator_base<IC,
                                           indexed_const_iterator2<C, IC>,
                                           typename C::value_type,
                                           typename C::difference_type> {
    public:
        typedef C container_type;
        typedef IC iterator_category;
        typedef typename container_type::size_type size_type;
        typedef typename container_type::difference_type difference_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::const_reference reference;

        typedef indexed_iterator2<container_type, iterator_category> iterator_type;
        typedef indexed_const_iterator1<container_type, iterator_category> dual_iterator_type;
        typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;


       
        indexed_const_iterator2 ():
            container_const_reference<container_type> (), it1_ (), it2_ () {}
       
        indexed_const_iterator2 (const container_type &c, size_type it1, size_type it2):
            container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
       
        indexed_const_iterator2 (const iterator_type &it):
            container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}


       
        indexed_const_iterator2 &operator ++ () {
            ++ it2_;
            return *this;
        }
       
        indexed_const_iterator2 &operator -- () {
            -- it2_;
            return *this;
        }
       
        indexed_const_iterator2 &operator += (difference_type n) {
            it2_ += n;
            return *this;
        }
       
        indexed_const_iterator2 &operator -= (difference_type n) {
            it2_ -= n;
            return *this;
        }
       
        difference_type operator - (const indexed_const_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1358 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1359 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ - it.it2_;
        }


       
        reference operator * () const {
            if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1366 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
            if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1367 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
            return (*this) () (it1_, it2_);
        }
       
        reference operator [] (difference_type n) const {
            return *((*this) + n);
        }


       
        size_type index1 () const {
            return it1_;
        }
       
        size_type index2 () const {
            return it2_;
        }

       
        dual_iterator_type begin () const {
            return (*this) ().find1 (1, 0, index2 ());
        }
       
        dual_iterator_type end () const {
            return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
        }
       
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
       
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }


       
        indexed_const_iterator2 &operator = (const indexed_const_iterator2 &it) {


            container_const_reference<C>::assign (&it ());
            it1_ = it.it1_;
            it2_ = it.it2_;
            return *this;
        }


       
        bool operator == (const indexed_const_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1416 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1417 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ == it.it2_;
        }
       
        bool operator < (const indexed_const_iterator2 &it) const {
            if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1422 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
            if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/iterator.hpp" << " at line " << 1423 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
            return it2_ < it.it2_;
        }

    private:
        size_type it1_;
        size_type it2_;

        friend class indexed_iterator2<container_type, iterator_category>;
    };

}}}
# 22 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp" 1
# 9 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp"
#define _BOOST_UBLAS_NUMERICTYPE_DEDUCTION_ 



# 1 "/usr/include/boost-1_41/boost/mpl/vector/vector20.hpp" 1


#define BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/vector/vector20.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/vector10.hpp" 1


#define BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/vector/vector10.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 1


#define BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp" 1


#define BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/at_fwd.hpp" 1


#define BOOST_MPL_AT_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/at_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/tag.hpp" 1


#define BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/tag.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/config/typeof.hpp" 1


#define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/config/typeof.hpp"
#define BOOST_MPL_CFG_HAS_TYPEOF 
# 34 "/usr/include/boost-1_41/boost/mpl/aux_/config/typeof.hpp"
#define BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES 
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/tag.hpp" 2


namespace boost { namespace mpl { namespace aux {

struct v_iter_tag;


struct vector_tag;




}}}
# 19 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/long.hpp" 1


#define BOOST_MPL_LONG_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/long.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/long_fwd.hpp" 1


#define BOOST_MPL_LONG_FWD_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/long_fwd.hpp"
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/usr/include/boost-1_41/boost/mpl/long.hpp" 2

#define AUX_WRAPPER_VALUE_TYPE long
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)



#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)






#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >



namespace mpl_ {

template< long N >
struct long_
{
    static const long value = N;





    typedef long_ type;

    typedef long value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::long_< static_cast<long>((value + 1)) > next;
    typedef mpl_::long_< static_cast<long>((value - 1)) > prior;






    operator long() const { return static_cast<long>(this->value); }
};


template< long N >
long const mpl_::long_< N >::value;


}

#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
# 21 "/usr/include/boost-1_41/boost/mpl/long.hpp" 2
# 20 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp" 2







namespace boost { namespace mpl {



template< typename Vector, long n_ >
struct v_at_impl
{
    typedef long_< (Vector::lower_bound_::value + n_) > index_;
    typedef __typeof__( Vector::item_(index_()) ) type;
};


template< typename Vector, long n_ >
struct v_at
    : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
{
};

template<>
struct at_impl< aux::vector_tag >
{
    template< typename Vector, typename N > struct apply
        : v_at<
              Vector
            , N::value
            >
    {
    };
};
# 114 "/usr/include/boost-1_41/boost/mpl/vector/aux_/at.hpp"
}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/front.hpp" 1


#define BOOST_MPL_VECTOR_AUX_FRONT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/front.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/front_fwd.hpp" 1


#define BOOST_MPL_FRONT_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct front_impl;
template< typename Sequence > struct front;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/front.hpp" 2






namespace boost { namespace mpl {



template<>
struct front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<Vector,0>
    {
    };
};
# 54 "/usr/include/boost-1_41/boost/mpl/vector/aux_/front.hpp"
}}
# 19 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_front.hpp" 1


#define BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_front.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/push_front_fwd.hpp" 1


#define BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/push_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_front_impl;
template< typename Sequence, typename T > struct push_front;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_front.hpp" 2




# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/item.hpp" 1


#define BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/mpl/vector/aux_/item.hpp"
namespace boost { namespace mpl {



template<
      typename T
    , typename Base
    , int at_front = 0
    >
struct v_item
    : Base
{
    typedef typename Base::upper_bound_ index_;
    typedef typename next<index_>::type upper_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;



    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};

template<
      typename T
    , typename Base
    >
struct v_item<T,Base,1>
    : Base
{
    typedef typename prior<typename Base::lower_bound_>::type index_;
    typedef index_ lower_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;

    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};


template<
      typename Base
    , int at_front
    >
struct v_mask
    : Base
{
    typedef typename prior<typename Base::upper_bound_>::type index_;
    typedef index_ upper_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};

template<
      typename Base
    >
struct v_mask<Base,1>
    : Base
{
    typedef typename Base::lower_bound_ index_;
    typedef typename next<index_>::type lower_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};



}}
# 23 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_front.hpp" 2


namespace boost { namespace mpl {

template<>
struct push_front_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,1> type;
    };
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_front.hpp" 1


#define BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_front.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/pop_front_fwd.hpp" 1


#define BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/pop_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_front_impl;
template< typename Sequence > struct pop_front;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_front.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,1> type;
    };
};

}}
# 21 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_back.hpp" 1


#define BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_back.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/push_back_fwd.hpp" 1


#define BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/push_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_back_impl;
template< typename Sequence, typename T > struct push_back;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/push_back.hpp" 2







namespace boost { namespace mpl {

template<>
struct push_back_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,0> type;
    };
};

}}
# 22 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_back.hpp" 1


#define BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_back.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/pop_back_fwd.hpp" 1


#define BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/pop_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/pop_back.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,0> type;
    };
};

}}
# 23 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/back.hpp" 1


#define BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/back.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/back_fwd.hpp" 1


#define BOOST_MPL_BACK_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct back_impl;
template< typename Sequence > struct back;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/back.hpp" 2






namespace boost { namespace mpl {



template<>
struct back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<
              Vector
            , prior<typename Vector::size>::type::value
            >
    {
    };
};
# 57 "/usr/include/boost-1_41/boost/mpl/vector/aux_/back.hpp"
}}
# 24 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/clear.hpp" 1


#define BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/clear.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/clear_fwd.hpp" 1


#define BOOST_MPL_CLEAR_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/clear_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct clear_impl;
template< typename Sequence > struct clear;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/clear.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/vector0.hpp" 1


#define BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/vector/aux_/vector0.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 1


#define BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/iterator_tags.hpp" 1


#define BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/iterator_tags.hpp"
namespace boost { namespace mpl {

struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };

}}
# 19 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/plus.hpp" 1


#define BOOST_MPL_PLUS_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/plus.hpp"
#define AUX778076_OP_NAME plus
#define AUX778076_OP_TOKEN +
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 1
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/largest_int.hpp" 1


#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/largest_int.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > struct integral_rank;

template<> struct integral_rank<bool> : int_<1> {};
template<> struct integral_rank<signed char> : int_<2> {};
template<> struct integral_rank<char> : int_<3> {};
template<> struct integral_rank<unsigned char> : int_<4> {};

template<> struct integral_rank<wchar_t> : int_<5> {};

template<> struct integral_rank<short> : int_<6> {};
template<> struct integral_rank<unsigned short> : int_<7> {};
template<> struct integral_rank<int> : int_<8> {};
template<> struct integral_rank<unsigned int> : int_<9> {};
template<> struct integral_rank<long> : int_<10> {};
template<> struct integral_rank<unsigned long> : int_<11> {};


template<> struct integral_rank<long_long_type> : int_<12> {};
template<> struct integral_rank<ulong_long_type>: int_<13> {};


template< typename T1, typename T2 > struct largest_int

    : if_c<
          ( integral_rank<T1>::value >= integral_rank<T2>::value )
        , T1
        , T2
        >
{






};

}}}
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 2




#define AUX778076_OP_PREFIX AUX778076_OP_NAME


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/plus.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct plus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct plus_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct plus_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct plus_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct plus_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct plus
    : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct plus< N1,N2,N3,N4,na >

    : plus< plus< plus< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct plus< N1,N2,N3,na,na >

    : plus< plus< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct plus< N1,N2,na,na,na >
    : plus_impl<
          typename plus_tag<N1>::type
        , typename plus_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct plus_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  + N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 35 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 2
# 87 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/plus.hpp" 2
# 20 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/minus.hpp" 1


#define BOOST_MPL_MINUS_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/minus.hpp"
#define AUX778076_OP_NAME minus
#define AUX778076_OP_TOKEN -
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/minus.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct minus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct minus_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct minus_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct minus_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct minus_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct minus
    : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct minus< N1,N2,N3,N4,na >

    : minus< minus< minus< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct minus< N1,N2,N3,na,na >

    : minus< minus< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct minus< N1,N2,na,na,na >
    : minus_impl<
          typename minus_tag<N1>::type
        , typename minus_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct minus_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  - N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 35 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp" 2
# 87 "/usr/include/boost-1_41/boost/mpl/aux_/arithmetic_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/minus.hpp" 2
# 21 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/advance_fwd.hpp" 1


#define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/advance_fwd.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;

}}
# 22 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/distance_fwd.hpp" 1


#define BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/distance_fwd.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct distance_impl;
template< typename First, typename Last > struct distance;

}}
# 23 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/prior.hpp" 1


#define BOOST_MPL_PRIOR_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp" 2





namespace boost { namespace mpl {

template<
      typename Vector
    , long n_
    >
struct v_iter
{
    typedef aux::v_iter_tag tag;
    typedef random_access_iterator_tag category;
    typedef typename v_at<Vector,n_>::type type;

    typedef Vector vector_;
    typedef mpl::long_<n_> pos;
# 56 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp"
};




template<
      typename Vector
    , long n_
    >
struct next< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ + 1)> type;
};

template<
      typename Vector
    , long n_
    >
struct prior< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ - 1)> type;
};

template<
      typename Vector
    , long n_
    , typename Distance
    >
struct advance< v_iter<Vector,n_>,Distance>
{
    typedef v_iter<
          Vector
        , (n_ + Distance::value)
        > type;
};

template<
      typename Vector
    , long n_
    , long m_
    >
struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
    : mpl::long_<(m_ - n_)>
{
};
# 128 "/usr/include/boost-1_41/boost/mpl/vector/aux_/iterator.hpp"
}}
# 23 "/usr/include/boost-1_41/boost/mpl/vector/aux_/vector0.hpp" 2



namespace boost { namespace mpl {

template< typename Dummy = na > struct vector0;

template<> struct vector0<na>
{

    typedef aux::vector_tag tag;
    typedef vector0 type;
    typedef long_<32768> lower_bound_;
    typedef lower_bound_ upper_bound_;
    typedef long_<0> size;

    static aux::type_wrapper<void_> item_(...);
# 48 "/usr/include/boost-1_41/boost/mpl/vector/aux_/vector0.hpp"
};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/vector/aux_/clear.hpp" 2




namespace boost { namespace mpl {



template<>
struct clear_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef vector0<> type;
    };
};
# 53 "/usr/include/boost-1_41/boost/mpl/vector/aux_/clear.hpp"
}}
# 25 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/O1_size.hpp" 1


#define BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/O1_size.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/O1_size_fwd.hpp" 1


#define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/O1_size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct O1_size_impl;
template< typename Sequence > struct O1_size;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/O1_size.hpp" 2






namespace boost { namespace mpl {



template<>
struct O1_size_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : Vector::size
    {
    };
};
# 54 "/usr/include/boost-1_41/boost/mpl/vector/aux_/O1_size.hpp"
}}
# 26 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/size.hpp" 1


#define BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/size.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/size_fwd.hpp" 1


#define BOOST_MPL_SIZE_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct size_impl;
template< typename Sequence > struct size;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/size.hpp" 2





namespace boost { namespace mpl {



template<>
struct size_impl< aux::vector_tag >
    : O1_size_impl< aux::vector_tag >
{
};
# 47 "/usr/include/boost-1_41/boost/mpl/vector/aux_/size.hpp"
}}
# 27 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/empty.hpp" 1


#define BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/vector/aux_/empty.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/empty_fwd.hpp" 1


#define BOOST_MPL_EMPTY_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/empty_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct empty_impl;
template< typename Sequence > struct empty;

}}
# 18 "/usr/include/boost-1_41/boost/mpl/vector/aux_/empty.hpp" 2






namespace boost { namespace mpl {



template<>
struct empty_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : is_same<
              typename Vector::lower_bound_
            , typename Vector::upper_bound_
            >
    {
    };
};
# 66 "/usr/include/boost-1_41/boost/mpl/vector/aux_/empty.hpp"
}}
# 28 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/begin_end.hpp" 1


#define BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/vector/aux_/begin_end.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/begin_end_fwd.hpp" 1


#define BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/begin_end_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct begin_impl;
template< typename Tag > struct end_impl;

template< typename Sequence > struct begin;
template< typename Sequence > struct end;

}}
# 22 "/usr/include/boost-1_41/boost/mpl/vector/aux_/begin_end.hpp" 2



namespace boost { namespace mpl {

template<>
struct begin_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,0> type;
    };
};

template<>
struct end_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,Vector::size::value> type;
    };
};

}}
# 32 "/usr/include/boost-1_41/boost/mpl/vector/vector0.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/vector/vector10.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER vector10.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
#define AUX778076_INCLUDE_DIR typeof_based
# 34 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
#define AUX778076_HEADER AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 49 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp"
namespace boost { namespace mpl {

template<
      typename T0
    >
struct vector1
    : v_item<
          T0
        , vector0< >
        >
{
    typedef vector1 type;
};

template<
      typename T0, typename T1
    >
struct vector2
    : v_item<
          T1
        , vector1<T0>
        >
{
    typedef vector2 type;
};

template<
      typename T0, typename T1, typename T2
    >
struct vector3
    : v_item<
          T2
        , vector2< T0,T1 >
        >
{
    typedef vector3 type;
};

template<
      typename T0, typename T1, typename T2, typename T3
    >
struct vector4
    : v_item<
          T3
        , vector3< T0,T1,T2 >
        >
{
    typedef vector4 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    >
struct vector5
    : v_item<
          T4
        , vector4< T0,T1,T2,T3 >
        >
{
    typedef vector5 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct vector6
    : v_item<
          T5
        , vector5< T0,T1,T2,T3,T4 >
        >
{
    typedef vector6 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6
    >
struct vector7
    : v_item<
          T6
        , vector6< T0,T1,T2,T3,T4,T5 >
        >
{
    typedef vector7 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7
    >
struct vector8
    : v_item<
          T7
        , vector7< T0,T1,T2,T3,T4,T5,T6 >
        >
{
    typedef vector8 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8
    >
struct vector9
    : v_item<
          T8
        , vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
        >
{
    typedef vector9 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    >
struct vector10
    : v_item<
          T9
        , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
        >
{
    typedef vector10 type;
};

}}
# 50 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp" 2


#undef AUX778076_HEADER
#undef AUX778076_INCLUDE_DIR

#undef BOOST_MPL_PREPROCESSED_HEADER
# 28 "/usr/include/boost-1_41/boost/mpl/vector/vector10.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/vector/vector20.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER vector20.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
#define AUX778076_INCLUDE_DIR typeof_based
# 34 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
#define AUX778076_HEADER AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 49 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp"
namespace boost { namespace mpl {

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10
    >
struct vector11
    : v_item<
          T10
        , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
        >
{
    typedef vector11 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11
    >
struct vector12
    : v_item<
          T11
        , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
        >
{
    typedef vector12 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12
    >
struct vector13
    : v_item<
          T12
        , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
        >
{
    typedef vector13 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13
    >
struct vector14
    : v_item<
          T13
        , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
        >
{
    typedef vector14 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    >
struct vector15
    : v_item<
          T14
        , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
        >
{
    typedef vector15 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15
    >
struct vector16
    : v_item<
          T15
        , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
        >
{
    typedef vector16 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16
    >
struct vector17
    : v_item<
          T16
        , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
        >
{
    typedef vector17 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17
    >
struct vector18
    : v_item<
          T17
        , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
        >
{
    typedef vector18 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18
    >
struct vector19
    : v_item<
          T18
        , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
        >
{
    typedef vector19 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18, typename T19
    >
struct vector20
    : v_item<
          T19
        , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
        >
{
    typedef vector20 type;
};

}}
# 50 "/usr/include/boost-1_41/boost/mpl/vector/aux_/include_preprocessed.hpp" 2


#undef AUX778076_HEADER
#undef AUX778076_INCLUDE_DIR

#undef BOOST_MPL_PREPROCESSED_HEADER
# 28 "/usr/include/boost-1_41/boost/mpl/vector/vector20.hpp" 2
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/at.hpp" 1


#define BOOST_MPL_AT_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/at.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/at_impl.hpp" 1


#define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/at_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/begin_end.hpp" 1


#define BOOST_MPL_BEGIN_END_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/begin_end.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp" 1


#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/sequence_tag_fwd.hpp" 1


#define BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/sequence_tag_fwd.hpp"
namespace boost { namespace mpl {

struct nested_begin_end_tag;
struct non_sequence_tag;

template< typename Sequence > struct sequence_tag;

}}
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/aux_/has_begin.hpp" 1


#define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/has_begin.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/traits_lambda_spec.hpp" 1


#define BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/traits_lambda_spec.hpp"
#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i,trait) 
# 58 "/usr/include/boost-1_41/boost/mpl/aux_/traits_lambda_spec.hpp"
#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i,trait) BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i, trait) template<> struct trait<non_sequence_tag> {};
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp" 2


namespace boost { namespace mpl {


namespace aux {

template< typename Sequence >
struct begin_type
{
    typedef typename Sequence::begin type;
};
template< typename Sequence >
struct end_type
{
    typedef typename Sequence::end type;
};

}





template< typename Tag >
struct begin_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::begin_type<Sequence>, void_>::type type;
    };
};

template< typename Tag >
struct end_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::end_type<Sequence>, void_>::type type;
    };
};



#define AUX778076_IMPL_SPEC(name,tag,result) template<> struct name ##_impl<tag> { template< typename Sequence > struct apply { typedef result type; }; };
# 82 "/usr/include/boost-1_41/boost/mpl/aux_/begin_end_impl.hpp"
template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };




template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };

#undef AUX778076_IMPL_SPEC





}}
# 19 "/usr/include/boost-1_41/boost/mpl/begin_end.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/sequence_tag.hpp" 1


#define BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/sequence_tag.hpp"
namespace boost { namespace mpl {
# 78 "/usr/include/boost-1_41/boost/mpl/sequence_tag.hpp"
namespace aux {

template< bool has_tag_, bool has_begin_ >
struct sequence_tag_impl
{


    template< typename Sequence > struct result2_;
};

#define AUX_CLASS_SEQUENCE_TAG_SPEC(has_tag,has_begin,result_type) template<> struct sequence_tag_impl<has_tag,has_begin> { template< typename Sequence > struct result2_ { typedef result_type type; }; };
# 98 "/usr/include/boost-1_41/boost/mpl/sequence_tag.hpp"
template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };

#undef AUX_CLASS_SEQUENCE_TAG_SPEC

}

template<
      typename Sequence = na
    >
struct sequence_tag
    : aux::sequence_tag_impl<
          ::boost::mpl::aux::has_tag<Sequence>::value
        , ::boost::mpl::aux::has_begin<Sequence>::value
        >::template result2_<Sequence>
{
};



template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/begin_end.hpp" 2



namespace boost { namespace mpl {




template<
      typename Sequence = na
    >
struct begin
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename begin_impl< tag_ >
        ::template apply< Sequence >::type type;

   
};

template<
      typename Sequence = na
    >
struct end
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename end_impl< tag_ >
        ::template apply< Sequence >::type type;

   
};

template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 1


#define BOOST_MPL_ADVANCE_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/advance.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/less.hpp" 1


#define BOOST_MPL_LESS_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/less.hpp"
#define AUX778076_OP_NAME less
#define AUX778076_OP_TOKEN <
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/less.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct less_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct less_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct less_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct less

    : less_impl<
          typename less_tag<N1>::type
        , typename less_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct less_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N2::value > N1::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/less.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/negate.hpp" 1


#define BOOST_MPL_NEGATE_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/mpl/negate.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct negate_impl;

template< typename T > struct negate_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct negate

    : negate_impl<
          typename negate_tag<N>::type
        >::template apply<N>::type






{
   
};

template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
# 65 "/usr/include/boost-1_41/boost/mpl/negate.hpp"
template<>
struct negate_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (-N::value) >

    {
    };
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/advance_forward.hpp" 1






#define BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/advance_forward.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/advance_forward.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER advance_forward.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp"
namespace boost { namespace mpl { namespace aux {

template< long N > struct advance_forward;
template<>
struct advance_forward<0>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef iter0 type;
    };
};

template<>
struct advance_forward<1>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef iter1 type;
    };
};

template<>
struct advance_forward<2>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef iter2 type;
    };
};

template<>
struct advance_forward<3>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef typename next<iter2>::type iter3;
        typedef iter3 type;
    };
};

template<>
struct advance_forward<4>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename next<iter0>::type iter1;
        typedef typename next<iter1>::type iter2;
        typedef typename next<iter2>::type iter3;
        typedef typename next<iter3>::type iter4;
        typedef iter4 type;
    };
};

template< long N >
struct advance_forward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_forward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_forward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 33 "/usr/include/boost-1_41/boost/mpl/aux_/advance_forward.hpp" 2
# 25 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/advance_backward.hpp" 1






#define BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/advance_backward.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/aux_/advance_backward.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER advance_backward.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp"
namespace boost { namespace mpl { namespace aux {

template< long N > struct advance_backward;
template<>
struct advance_backward<0>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef iter0 type;
    };
};

template<>
struct advance_backward<1>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef iter1 type;
    };
};

template<>
struct advance_backward<2>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef iter2 type;
    };
};

template<>
struct advance_backward<3>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef typename prior<iter2>::type iter3;
        typedef iter3 type;
    };
};

template<>
struct advance_backward<4>
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;
        typedef typename prior<iter0>::type iter1;
        typedef typename prior<iter1>::type iter2;
        typedef typename prior<iter2>::type iter3;
        typedef typename prior<iter3>::type iter4;
        typedef iter4 type;
    };
};

template< long N >
struct advance_backward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_backward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_backward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 33 "/usr/include/boost-1_41/boost/mpl/aux_/advance_backward.hpp" 2
# 26 "/usr/include/boost-1_41/boost/mpl/advance.hpp" 2




namespace boost { namespace mpl {


template< typename Tag >
struct advance_impl
{
    template< typename Iterator, typename N > struct apply
    {
        typedef typename less< N,long_<0> >::type backward_;
        typedef typename if_< backward_, negate<N>, N >::type offset_;

        typedef typename if_<
              backward_
            , aux::advance_backward< offset_::value >
            , aux::advance_forward< offset_::value >
            >::type f_;

        typedef typename apply_wrap1<f_,Iterator>::type type;
    };
};


template<
      typename Iterator = na
    , typename N = na
    >
struct advance
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,N>
{
};

template<
      typename Iterator
    , long N
    >
struct advance_c
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,long_<N> >
{
};

template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/deref.hpp" 1


#define BOOST_MPL_DEREF_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/deref.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_type.hpp" 1


#define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_type.hpp"
namespace boost { namespace mpl { namespace aux {
# 48 "/usr/include/boost-1_41/boost/mpl/aux_/msvc_type.hpp"
template< typename T > struct msvc_type
{
    typedef typename T::type type;
};

template<> struct msvc_type<int>
{
    typedef int type;
};



}}}
# 18 "/usr/include/boost-1_41/boost/mpl/deref.hpp" 2




namespace boost { namespace mpl {

template<
      typename Iterator = na
    >
struct deref
{

    typedef typename Iterator::type type;



   
};

template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/at_impl.hpp" 2


namespace boost { namespace mpl {




template< typename Tag >
struct at_impl
{
    template< typename Sequence, typename N > struct apply
    {
        typedef typename advance<
              typename begin<Sequence>::type
            , N
            >::type iter_;

        typedef typename deref<iter_>::type type;
    };
};

 template<> struct at_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/at.hpp" 2






namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename N = na
    >
struct at
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,N >
{
   
};

template<
      typename Sequence
    , long N
    >
struct at_c
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,mpl::long_<N> >
{
};

template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }

}}
# 15 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/or.hpp" 1


#define BOOST_MPL_OR_HPP_INCLUDED 
# 42 "/usr/include/boost-1_41/boost/mpl/or.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER or.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/or.hpp"
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct or_impl
    : true_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct or_impl< false,T1,T2,T3,T4 >
    : or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , false_
        >
{
};

template<>
struct or_impl<
          false
        , false_, false_, false_, false_
        >
    : false_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = false_, typename T4 = false_, typename T5 = false_
    >
struct or_

    : aux::or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct or_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 44 "/usr/include/boost-1_41/boost/mpl/or.hpp" 2
# 16 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp" 2



# 1 "/usr/include/boost-1_41/boost/utility/enable_if.hpp" 1
# 15 "/usr/include/boost-1_41/boost/utility/enable_if.hpp"
#define BOOST_UTILITY_ENABLE_IF_HPP 
# 24 "/usr/include/boost-1_41/boost/utility/enable_if.hpp"
namespace boost
{

  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};

  template <class Cond, class T = void>
  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T>
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};


  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };

  template <class T>
  struct disable_if_c<true, T> {};

  template <class Cond, class T = void>
  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T>
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

}
# 20 "/usr/include/boost-1_41/boost/numeric/ublas/detail/returntype_deduction.hpp" 2

namespace boost { namespace numeric { namespace ublas {

struct error_cant_deduce_type {};

  namespace type_deduction_detail
  {
    typedef char(&bool_value_type)[1];
    typedef char(&float_value_type)[2];
    typedef char(&double_value_type)[3];
    typedef char(&long_double_value_type)[4];
    typedef char(&char_value_type)[5];
    typedef char(&schar_value_type)[6];
    typedef char(&uchar_value_type)[7];
    typedef char(&short_value_type)[8];
    typedef char(&ushort_value_type)[9];
    typedef char(&int_value_type)[10];
    typedef char(&uint_value_type)[11];
    typedef char(&long_value_type)[12];
    typedef char(&ulong_value_type)[13];

    typedef char(&x_value_type)[14];
    typedef char(&y_value_type)[15];

    typedef char(&cant_deduce_type)[16];

    template <typename T, typename PlainT = typename remove_cv<T>::type>
    struct is_basic
        : mpl::or_<
          typename mpl::or_<
              is_same<PlainT, bool>
            , is_same<PlainT, float>
            , is_same<PlainT, double>
            , is_same<PlainT, long double>
          > ::type,
          typename mpl::or_<
              is_same<PlainT, char>
            , is_same<PlainT, signed char>
            , is_same<PlainT, unsigned char>
            , is_same<PlainT, short>
            , is_same<PlainT, unsigned short>
            > ::type,
          typename mpl::or_<
              is_same<PlainT, int>
            , is_same<PlainT, unsigned int>
            , is_same<PlainT, long>
            , is_same<PlainT, unsigned long>
            > ::type
        > {};

    struct asymmetric;

    template <typename X, typename Y>
    cant_deduce_type
    test(...);

    template <typename X, typename Y>
    bool_value_type
    test(bool const&);

    template <typename X, typename Y>
    float_value_type
    test(float const&);

    template <typename X, typename Y>
    double_value_type
    test(double const&);

    template <typename X, typename Y>
    long_double_value_type
    test(long double const&);

    template <typename X, typename Y>
    char_value_type
    test(char const&);

    template <typename X, typename Y>
    schar_value_type
    test(signed char const&);

    template <typename X, typename Y>
    uchar_value_type
    test(unsigned char const&);

    template <typename X, typename Y>
    short_value_type
    test(short const&);

    template <typename X, typename Y>
    ushort_value_type
    test(unsigned short const&);

    template <typename X, typename Y>
    int_value_type
    test(int const&);

    template <typename X, typename Y>
    uint_value_type
    test(unsigned int const&);

    template <typename X, typename Y>
    long_value_type
    test(long const&);

    template <typename X, typename Y>
    ulong_value_type
    test(unsigned long const&);

    template <typename X, typename Y>
    typename disable_if<
        is_basic<X>, x_value_type
    >::type
    test(X const&);

    template <typename X, typename Y>
    typename disable_if<
        mpl::or_<
            is_basic<Y>
          , is_same<Y, asymmetric>
          , is_same<const X, const Y>
        >
      , y_value_type
    >::type
    test(Y const&);

    template <typename X, typename Y>
    struct base_result_of
    {
        typedef typename remove_cv<X>::type x_type;
        typedef typename remove_cv<Y>::type y_type;

        typedef mpl::vector16<
            mpl::identity<bool>
          , mpl::identity<float>
          , mpl::identity<double>
          , mpl::identity<long double>
          , mpl::identity<char>
          , mpl::identity<signed char>
          , mpl::identity<unsigned char>
          , mpl::identity<short>
          , mpl::identity<unsigned short>
          , mpl::identity<int>
          , mpl::identity<unsigned int>
          , mpl::identity<long>
          , mpl::identity<unsigned long>
          , mpl::identity<x_type>
          , mpl::identity<y_type>
          , mpl::identity<error_cant_deduce_type>
        >
        types;
    };

}}} }
# 23 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits.hpp"
#define BOOST_TYPE_TRAITS_HPP 

# 1 "/usr/include/boost-1_41/boost/type_traits/add_const.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/add_const.hpp"
#define BOOST_TT_ADD_CONST_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 17 "/usr/include/boost-1_41/boost/type_traits/add_const.hpp" 2

namespace boost {
# 33 "/usr/include/boost-1_41/boost/type_traits/add_const.hpp"
template< typename T > struct add_const { typedef T const type; };






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


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 46 "/usr/include/boost-1_41/boost/type_traits/add_const.hpp" 2
# 14 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/add_cv.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/add_cv.hpp"
#define BOOST_TT_ADD_CV_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 18 "/usr/include/boost-1_41/boost/type_traits/add_cv.hpp" 2

namespace boost {
# 34 "/usr/include/boost-1_41/boost/type_traits/add_cv.hpp"
template< typename T > struct add_cv { typedef T const volatile type; };






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


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 47 "/usr/include/boost-1_41/boost/type_traits/add_cv.hpp" 2
# 15 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/add_pointer.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/add_pointer.hpp"
#define BOOST_TT_ADD_POINTER_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 16 "/usr/include/boost-1_41/boost/type_traits/add_pointer.hpp" 2

namespace boost {

namespace detail {
# 55 "/usr/include/boost-1_41/boost/type_traits/add_pointer.hpp"
template <typename T>
struct add_pointer_impl
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};



}

template< typename T > struct add_pointer { typedef typename boost::detail::add_pointer_impl<T>::type type; };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 71 "/usr/include/boost-1_41/boost/type_traits/add_pointer.hpp" 2
# 16 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/add_volatile.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/add_volatile.hpp"
#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 17 "/usr/include/boost-1_41/boost/type_traits/add_volatile.hpp" 2

namespace boost {
# 33 "/usr/include/boost-1_41/boost/type_traits/add_volatile.hpp"
template< typename T > struct add_volatile { typedef T volatile type; };






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


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 46 "/usr/include/boost-1_41/boost/type_traits/add_volatile.hpp" 2
# 18 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp"
#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/size_t.hpp" 1


#define BOOST_MPL_SIZE_T_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/size_t.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/size_t_fwd.hpp" 1


#define BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/size_t_fwd.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/mpl/size_t_fwd.hpp" 2

namespace mpl_ {

template< std::size_t N > struct size_t;

}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
# 18 "/usr/include/boost-1_41/boost/mpl/size_t.hpp" 2

#define AUX_WRAPPER_VALUE_TYPE std::size_t
#define AUX_WRAPPER_NAME size_t
#define AUX_WRAPPER_PARAMS(N) std::size_t N

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp" 1
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >



namespace mpl_ {

template< std::size_t N >
struct size_t
{
    static const std::size_t value = N;





    typedef size_t type;

    typedef std::size_t value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost-1_41/boost/mpl/aux_/integral_wrapper.hpp"
    typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
    typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;






    operator std::size_t() const { return static_cast<std::size_t>(this->value); }
};


template< std::size_t N >
std::size_t const mpl_::size_t< N >::value;


}

#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
# 24 "/usr/include/boost-1_41/boost/mpl/size_t.hpp" 2
# 18 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2


#define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) 
# 33 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) template< typename T > struct trait : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 44 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) template<> struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
# 53 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) template< param > struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { };
# 18 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp" 2
# 27 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp"
namespace boost {

template <typename T> struct alignment_of;


namespace detail {





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




template <unsigned A, unsigned S>
struct alignment_logic
{
    static const std::size_t value = A < S ? A : S;
};


template< typename T >
struct alignment_of_impl
{
# 83 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp"
   static const std::size_t value = __alignof__(T);

};

}

template< typename T > struct alignment_of : ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { };




template <typename T>
struct alignment_of<T&>
    : alignment_of<T*>
{
};
# 109 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp"
template<> struct alignment_of<void> : ::boost::integral_constant<std::size_t,0> { };

template<> struct alignment_of<void const> : ::boost::integral_constant<std::size_t,0> { };
template<> struct alignment_of<void volatile> : ::boost::integral_constant<std::size_t,0> { };
template<> struct alignment_of<void const volatile> : ::boost::integral_constant<std::size_t,0> { };


}
# 125 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp"
#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1
# 126 "/usr/include/boost-1_41/boost/type_traits/alignment_of.hpp" 2
# 19 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_assign.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_assign.hpp"
#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp"
#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED 



# 1 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp"
#define BOOST_TT_IS_POD_HPP_INCLUDED 



# 1 "/usr/include/boost-1_41/boost/type_traits/is_scalar.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_scalar.hpp"
#define BOOST_TT_IS_SCALAR_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/type_traits/is_scalar.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 21 "/usr/include/boost-1_41/boost/type_traits/is_scalar.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_scalar_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value);






};



template <> struct is_scalar_impl<void>{ static const bool value = false; };

template <> struct is_scalar_impl<void const>{ static const bool value = false; };
template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };


}

template< typename T > struct is_scalar : ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 54 "/usr/include/boost-1_41/boost/type_traits/is_scalar.hpp" 2
# 15 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp" 2



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 19 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 22 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp" 2

namespace boost {


template< typename T > struct is_POD;

namespace detail {



template <typename T> struct is_pod_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, __is_pod(T) >::value);






};


template <typename T, std::size_t sz>
struct is_pod_impl<T[sz]>
    : is_pod_impl<T>
{
};
# 118 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp"
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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 134 "/usr/include/boost-1_41/boost/type_traits/is_pod.hpp" 2
# 15 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp" 2







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 23 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_assign_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_assign(T) >::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);
# 40 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp"
};

}

template< typename T > struct has_trivial_assign : ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 49 "/usr/include/boost-1_41/boost/type_traits/has_trivial_assign.hpp" 2
# 13 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_assign.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_assign.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_assign_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_assign<T>::value, (__has_nothrow_assign(T) && !is_volatile<T>::value) >::value);




};

}

template< typename T > struct has_nothrow_assign : ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 37 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_assign.hpp" 2
# 20 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_constructor.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_constructor.hpp"
#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/has_trivial_constructor.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_trivial_constructor.hpp"
#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED 







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 19 "/usr/include/boost-1_41/boost/type_traits/has_trivial_constructor.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_ctor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_constructor(T) >::value);




};

}

template< typename T > struct has_trivial_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
template< typename T > struct has_trivial_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 42 "/usr/include/boost-1_41/boost/type_traits/has_trivial_constructor.hpp" 2
# 13 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_constructor.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_constructor.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_constructor_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_constructor<T>::value, __has_nothrow_constructor(T) >::value);




};

}

template< typename T > struct has_nothrow_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
template< typename T > struct has_nothrow_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 38 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_constructor.hpp" 2
# 21 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_copy.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_copy.hpp"
#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/has_trivial_copy.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_trivial_copy.hpp"
#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/has_trivial_copy.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 22 "/usr/include/boost-1_41/boost/type_traits/has_trivial_copy.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_copy_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, (__has_trivial_copy(T) && !is_reference<T>::value) >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);







};

}

template< typename T > struct has_trivial_copy : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
template< typename T > struct has_trivial_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 48 "/usr/include/boost-1_41/boost/type_traits/has_trivial_copy.hpp" 2
# 13 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_copy.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_copy.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_copy_imp{
   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_copy<T>::value, (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value) >::value);




};

}

template< typename T > struct has_nothrow_copy : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
template< typename T > struct has_nothrow_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 38 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_copy.hpp" 2
# 22 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_destructor.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_destructor.hpp"
#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED 

# 1 "/usr/include/boost-1_41/boost/type_traits/has_trivial_destructor.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/has_trivial_destructor.hpp"
#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED 







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 19 "/usr/include/boost-1_41/boost/type_traits/has_trivial_destructor.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_dtor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_destructor(T) >::value);




};

}

template< typename T > struct has_trivial_destructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 41 "/usr/include/boost-1_41/boost/type_traits/has_trivial_destructor.hpp" 2
# 13 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_destructor.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_destructor.hpp" 2

namespace boost {

template< typename T > struct has_nothrow_destructor : ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 24 "/usr/include/boost-1_41/boost/type_traits/has_nothrow_destructor.hpp" 2
# 23 "/usr/include/boost-1_41/boost/type_traits.hpp" 2




# 1 "/usr/include/boost-1_41/boost/type_traits/has_virtual_destructor.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/has_virtual_destructor.hpp"
#define BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED 



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 16 "/usr/include/boost-1_41/boost/type_traits/has_virtual_destructor.hpp" 2

namespace boost {

template< typename T > struct has_virtual_destructor : ::boost::integral_constant<bool,__has_virtual_destructor(T)> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 24 "/usr/include/boost-1_41/boost/type_traits/has_virtual_destructor.hpp" 2
# 28 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_signed.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/is_signed.hpp"
#define BOOST_TT_IS_SIGNED_HPP_INCLUDED 







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 20 "/usr/include/boost-1_41/boost/type_traits/is_signed.hpp" 2

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-1_41/boost/type_traits/is_signed.hpp"
}






template< typename T > struct is_signed : ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 126 "/usr/include/boost-1_41/boost/type_traits/is_signed.hpp" 2
# 29 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_unsigned.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/is_unsigned.hpp"
#define BOOST_TT_IS_UNSIGNED_HPP_INCLUDED 







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 20 "/usr/include/boost-1_41/boost/type_traits/is_unsigned.hpp" 2

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-1_41/boost/type_traits/is_unsigned.hpp"
}






template< typename T > struct is_unsigned : ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 122 "/usr/include/boost-1_41/boost/type_traits/is_unsigned.hpp" 2
# 30 "/usr/include/boost-1_41/boost/type_traits.hpp" 2




# 1 "/usr/include/boost-1_41/boost/type_traits/is_base_of.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_base_of.hpp"
#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/type_traits/is_base_of.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 20 "/usr/include/boost-1_41/boost/type_traits/is_base_of.hpp" 2

namespace boost {

   namespace detail{
      template <class B, class D>
      struct is_base_of_imp
      {
          typedef typename remove_cv<B>::type ncvB;
          typedef typename remove_cv<D>::type ncvD;
          static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value);


      };
   }

template< typename Base, typename Derived > struct is_base_of : ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { };






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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 50 "/usr/include/boost-1_41/boost/type_traits/is_base_of.hpp" 2
# 35 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/is_compound.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_compound.hpp"
#define BOOST_TT_IS_COMPOUND_HPP_INCLUDED 






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 18 "/usr/include/boost-1_41/boost/type_traits/is_compound.hpp" 2

namespace boost {


namespace detail {

template <typename T>
struct is_compound_impl
{
   static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value);



};

}





template< typename T > struct is_compound : ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 45 "/usr/include/boost-1_41/boost/type_traits/is_compound.hpp" 2
# 37 "/usr/include/boost-1_41/boost/type_traits.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp"
#define BOOST_TT_IS_EMPTY_HPP_INCLUDED 
# 32 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 33 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp" 2

namespace boost {

namespace detail {


template <typename T>
struct empty_helper_t1 : public T
{
    empty_helper_t1();
    int i[256];
private:

   empty_helper_t1(const empty_helper_t1&);
   empty_helper_t1& operator=(const empty_helper_t1&);
};

struct empty_helper_t2 { int i[256]; };



template <typename T, bool is_a_class = false>
struct empty_helper
{
    static const bool value = false;
};

template <typename T>
struct empty_helper<T, true>
{
    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));


};

template <typename T>
struct is_empty_impl
{
    typedef typename remove_cv<T>::type cvt;
    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , __is_empty(cvt) >::value );






};
# 195 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp"
template<> struct is_empty_impl< void > { static const bool value = (false); };

template<> struct is_empty_impl< void const > { static const bool value = (false); };
template<> struct is_empty_impl< void volatile > { static const bool value = (false); };
template<> struct is_empty_impl< void const volatile > { static const bool value = (false); };


}

template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 209 "/usr/include/boost-1_41/boost/type_traits/is_empty.hpp" 2
# 40 "/usr/include/boost-1_41/boost/type_traits.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/is_floating_point.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_floating_point.hpp"
#define BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 14 "/usr/include/boost-1_41/boost/type_traits/is_floating_point.hpp" 2

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-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 26 "/usr/include/boost-1_41/boost/type_traits/is_floating_point.hpp" 2
# 43 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp"
#define BOOST_TT_IS_FUNCTION_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/false_result.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/detail/false_result.hpp"
#define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED 



namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}}
# 16 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/is_function_ptr_helper.hpp" 1
# 16 "/usr/include/boost-1_41/boost/type_traits/detail/is_function_ptr_helper.hpp"
#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/type_traits/detail/is_function_ptr_helper.hpp"
namespace boost {
namespace type_traits {

template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};




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

template <class R >
struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
# 203 "/usr/include/boost-1_41/boost/type_traits/detail/is_function_ptr_helper.hpp"
}
}
# 20 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 27 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp" 2







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-1_41/boost/type_traits/is_function.hpp"
}






template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 102 "/usr/include/boost-1_41/boost/type_traits/is_function.hpp" 2
# 44 "/usr/include/boost-1_41/boost/type_traits.hpp" 2



# 1 "/usr/include/boost-1_41/boost/type_traits/is_member_object_pointer.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/is_member_object_pointer.hpp"
#define BOOST_TT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/type_traits/is_member_object_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 21 "/usr/include/boost-1_41/boost/type_traits/is_member_object_pointer.hpp" 2

namespace boost {

namespace detail{

template <typename T>
struct is_member_object_pointer_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value );






};

}

template< typename T > struct is_member_object_pointer : ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 45 "/usr/include/boost-1_41/boost/type_traits/is_member_object_pointer.hpp" 2
# 48 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp"
#define BOOST_TT_IS_OBJECT_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 21 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_object_impl
{

   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value);
# 43 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp"
};

}

template< typename T > struct is_object : ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 52 "/usr/include/boost-1_41/boost/type_traits/is_object.hpp" 2
# 50 "/usr/include/boost-1_41/boost/type_traits.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/is_stateless.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/is_stateless.hpp"
#define BOOST_TT_IS_STATELESS_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/is_stateless.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 22 "/usr/include/boost-1_41/boost/type_traits/is_stateless.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_stateless_impl
{
  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value);







};

}

template< typename T > struct is_stateless : ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 47 "/usr/include/boost-1_41/boost/type_traits/is_stateless.hpp" 2
# 57 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_union.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/is_union.hpp"
#define BOOST_TT_IS_UNION_HPP_INCLUDED 






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 20 "/usr/include/boost-1_41/boost/type_traits/is_union.hpp" 2

namespace boost {

namespace detail {
# 36 "/usr/include/boost-1_41/boost/type_traits/is_union.hpp"
template <typename T> struct is_union_impl
{
   static const bool value = __is_union(T);
};

}

template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 48 "/usr/include/boost-1_41/boost/type_traits/is_union.hpp" 2
# 58 "/usr/include/boost-1_41/boost/type_traits.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/rank.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/rank.hpp"
#define BOOST_TT_RANK_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2


#define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) 
# 33 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) template< typename T > struct trait : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 44 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) template<> struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
# 53 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) template< param > struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { };
# 15 "/usr/include/boost-1_41/boost/type_traits/rank.hpp" 2

namespace boost {



namespace detail{

template <class T, std::size_t N>
struct rank_imp
{
   static const std::size_t value = N;
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


template <class T, std::size_t N>
struct rank_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


}






template< typename T > struct rank : ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { };


}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp"
#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1
# 88 "/usr/include/boost-1_41/boost/type_traits/rank.hpp" 2
# 61 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/extent.hpp" 1
# 11 "/usr/include/boost-1_41/boost/type_traits/extent.hpp"
#define BOOST_TT_EXTENT_HPP_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 20 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp" 2


#define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) 
# 33 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) template< typename T > struct trait : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 44 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) template<> struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
# 53 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_def.hpp"
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) template< param > struct trait<spec> : BOOST_TT_AUX_SIZE_T_BASE(C) { };
# 15 "/usr/include/boost-1_41/boost/type_traits/extent.hpp" 2

namespace boost {

namespace detail{
# 29 "/usr/include/boost-1_41/boost/type_traits/extent.hpp"
template <class T, std::size_t N>
struct extent_imp
{
   static const std::size_t value = 0;
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R>
struct extent_imp<T[R],0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T volatile[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const volatile[R], 0>
{
   static const std::size_t value = R;
};


template <class T, std::size_t N>
struct extent_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T>
struct extent_imp<T[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T volatile[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const volatile[], 0>
{
   static const std::size_t value = 0;
};




}

template <class T, std::size_t N = 0>
struct extent
   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{




   
};

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/size_t_trait_undef.hpp"
#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1
# 144 "/usr/include/boost-1_41/boost/type_traits/extent.hpp" 2
# 62 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/remove_bounds.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/remove_bounds.hpp"
#define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_41/boost/type_traits/remove_bounds.hpp" 2







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/remove_bounds.hpp" 2



namespace boost {

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


template< typename T, std::size_t N > struct remove_bounds<T[N]> { typedef T type; };
template< typename T, std::size_t N > struct remove_bounds<T const[N]> { typedef T const type; };
template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { typedef T volatile type; };
template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { typedef T const volatile type; };

template< typename T > struct remove_bounds<T[]> { typedef T type; };
template< typename T > struct remove_bounds<T const[]> { typedef T const type; };
template< typename T > struct remove_bounds<T volatile[]> { typedef T volatile type; };
template< typename T > struct remove_bounds<T const volatile[]> { typedef T const volatile type; };



}



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 47 "/usr/include/boost-1_41/boost/type_traits/remove_bounds.hpp" 2
# 63 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/remove_extent.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/remove_extent.hpp"
#define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED 



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 15 "/usr/include/boost-1_41/boost/type_traits/remove_extent.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/remove_extent.hpp" 2



namespace boost {

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


template< typename T, std::size_t N > struct remove_extent<T[N]> { typedef T type; };
template< typename T, std::size_t N > struct remove_extent<T const[N]> { typedef T const type; };
template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { typedef T volatile type; };
template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { typedef T const volatile type; };

template< typename T > struct remove_extent<T[]> { typedef T type; };
template< typename T > struct remove_extent<T const[]> { typedef T const type; };
template< typename T > struct remove_extent<T volatile[]> { typedef T volatile type; };
template< typename T > struct remove_extent<T const volatile[]> { typedef T const volatile type; };



}



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 47 "/usr/include/boost-1_41/boost/type_traits/remove_extent.hpp" 2
# 64 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/remove_all_extents.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/remove_all_extents.hpp"
#define BOOST_TT_REMOVE_ALL_EXTENTS_HPP_INCLUDED 


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_41/boost/type_traits/remove_all_extents.hpp" 2







# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/remove_all_extents.hpp" 2



namespace boost {

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


template< typename T, std::size_t N > struct remove_all_extents<T[N]> { typedef typename boost::remove_all_extents<T>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };

template< typename T > struct remove_all_extents<T[]> { typedef typename boost::remove_all_extents<T>::type type; };
template< typename T > struct remove_all_extents<T const[]> { typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T > struct remove_all_extents<T volatile[]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T > struct remove_all_extents<T const volatile[]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };



}



# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 47 "/usr/include/boost-1_41/boost/type_traits/remove_all_extents.hpp" 2
# 65 "/usr/include/boost-1_41/boost/type_traits.hpp" 2


# 1 "/usr/include/boost-1_41/boost/type_traits/remove_pointer.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/remove_pointer.hpp"
#define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/remove_pointer.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/remove_pointer.hpp" 2

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-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 42 "/usr/include/boost-1_41/boost/type_traits/remove_pointer.hpp" 2
# 68 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp" 1
# 12 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp"
#define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED 







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 21 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 28 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp" 2

namespace boost {



namespace detail {

template <typename T, bool is_const>
struct remove_volatile_helper
{
    typedef T type;
};

template <typename T>
struct remove_volatile_helper<T,true>
{
    typedef T const type;
};

template <typename T>
struct remove_volatile_impl
{
    typedef typename remove_volatile_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_const<T>::value
        >::type type;
};

}



template< typename T > struct remove_volatile { typedef typename boost::detail::remove_volatile_impl<T>::type type; };
template< typename T > struct remove_volatile<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { typedef T const type[N]; };
# 73 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp"
}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 76 "/usr/include/boost-1_41/boost/type_traits/remove_volatile.hpp" 2
# 70 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED 


# 1 "/usr/include/boost-1_41/boost/preprocessor/list/for_each_i.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/for_each_i.hpp"
#define BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP 




# 1 "/usr/include/boost-1_41/boost/preprocessor/repetition/for.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/repetition/for.hpp"
#define BOOST_PREPROCESSOR_REPETITION_FOR_HPP 



# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 20 "/usr/include/boost-1_41/boost/preprocessor/repetition/for.hpp" 2







#define BOOST_PP_FOR BOOST_PP_CAT(BOOST_PP_FOR_, BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256))

#define BOOST_PP_FOR_P(n) BOOST_PP_CAT(BOOST_PP_FOR_CHECK_, BOOST_PP_FOR_ ## n(1, BOOST_PP_FOR_SR_P, BOOST_PP_FOR_SR_O, BOOST_PP_FOR_SR_M))

#define BOOST_PP_FOR_SR_P(r,s) s
#define BOOST_PP_FOR_SR_O(r,s) 0
#define BOOST_PP_FOR_SR_M(r,s) BOOST_PP_NIL
# 42 "/usr/include/boost-1_41/boost/preprocessor/repetition/for.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/repetition/detail/for.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/repetition/detail/for.hpp"
#define BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP 






#define BOOST_PP_FOR_1(s,p,o,m) BOOST_PP_FOR_1_C(BOOST_PP_BOOL(p(2, s)), s, p, o, m)
#define BOOST_PP_FOR_2(s,p,o,m) BOOST_PP_FOR_2_C(BOOST_PP_BOOL(p(3, s)), s, p, o, m)
#define BOOST_PP_FOR_3(s,p,o,m) BOOST_PP_FOR_3_C(BOOST_PP_BOOL(p(4, s)), s, p, o, m)
#define BOOST_PP_FOR_4(s,p,o,m) BOOST_PP_FOR_4_C(BOOST_PP_BOOL(p(5, s)), s, p, o, m)
#define BOOST_PP_FOR_5(s,p,o,m) BOOST_PP_FOR_5_C(BOOST_PP_BOOL(p(6, s)), s, p, o, m)
#define BOOST_PP_FOR_6(s,p,o,m) BOOST_PP_FOR_6_C(BOOST_PP_BOOL(p(7, s)), s, p, o, m)
#define BOOST_PP_FOR_7(s,p,o,m) BOOST_PP_FOR_7_C(BOOST_PP_BOOL(p(8, s)), s, p, o, m)
#define BOOST_PP_FOR_8(s,p,o,m) BOOST_PP_FOR_8_C(BOOST_PP_BOOL(p(9, s)), s, p, o, m)
#define BOOST_PP_FOR_9(s,p,o,m) BOOST_PP_FOR_9_C(BOOST_PP_BOOL(p(10, s)), s, p, o, m)
#define BOOST_PP_FOR_10(s,p,o,m) BOOST_PP_FOR_10_C(BOOST_PP_BOOL(p(11, s)), s, p, o, m)
#define BOOST_PP_FOR_11(s,p,o,m) BOOST_PP_FOR_11_C(BOOST_PP_BOOL(p(12, s)), s, p, o, m)
#define BOOST_PP_FOR_12(s,p,o,m) BOOST_PP_FOR_12_C(BOOST_PP_BOOL(p(13, s)), s, p, o, m)
#define BOOST_PP_FOR_13(s,p,o,m) BOOST_PP_FOR_13_C(BOOST_PP_BOOL(p(14, s)), s, p, o, m)
#define BOOST_PP_FOR_14(s,p,o,m) BOOST_PP_FOR_14_C(BOOST_PP_BOOL(p(15, s)), s, p, o, m)
#define BOOST_PP_FOR_15(s,p,o,m) BOOST_PP_FOR_15_C(BOOST_PP_BOOL(p(16, s)), s, p, o, m)
#define BOOST_PP_FOR_16(s,p,o,m) BOOST_PP_FOR_16_C(BOOST_PP_BOOL(p(17, s)), s, p, o, m)
#define BOOST_PP_FOR_17(s,p,o,m) BOOST_PP_FOR_17_C(BOOST_PP_BOOL(p(18, s)), s, p, o, m)
#define BOOST_PP_FOR_18(s,p,o,m) BOOST_PP_FOR_18_C(BOOST_PP_BOOL(p(19, s)), s, p, o, m)
#define BOOST_PP_FOR_19(s,p,o,m) BOOST_PP_FOR_19_C(BOOST_PP_BOOL(p(20, s)), s, p, o, m)
#define BOOST_PP_FOR_20(s,p,o,m) BOOST_PP_FOR_20_C(BOOST_PP_BOOL(p(21, s)), s, p, o, m)
#define BOOST_PP_FOR_21(s,p,o,m) BOOST_PP_FOR_21_C(BOOST_PP_BOOL(p(22, s)), s, p, o, m)
#define BOOST_PP_FOR_22(s,p,o,m) BOOST_PP_FOR_22_C(BOOST_PP_BOOL(p(23, s)), s, p, o, m)
#define BOOST_PP_FOR_23(s,p,o,m) BOOST_PP_FOR_23_C(BOOST_PP_BOOL(p(24, s)), s, p, o, m)
#define BOOST_PP_FOR_24(s,p,o,m) BOOST_PP_FOR_24_C(BOOST_PP_BOOL(p(25, s)), s, p, o, m)
#define BOOST_PP_FOR_25(s,p,o,m) BOOST_PP_FOR_25_C(BOOST_PP_BOOL(p(26, s)), s, p, o, m)
#define BOOST_PP_FOR_26(s,p,o,m) BOOST_PP_FOR_26_C(BOOST_PP_BOOL(p(27, s)), s, p, o, m)
#define BOOST_PP_FOR_27(s,p,o,m) BOOST_PP_FOR_27_C(BOOST_PP_BOOL(p(28, s)), s, p, o, m)
#define BOOST_PP_FOR_28(s,p,o,m) BOOST_PP_FOR_28_C(BOOST_PP_BOOL(p(29, s)), s, p, o, m)
#define BOOST_PP_FOR_29(s,p,o,m) BOOST_PP_FOR_29_C(BOOST_PP_BOOL(p(30, s)), s, p, o, m)
#define BOOST_PP_FOR_30(s,p,o,m) BOOST_PP_FOR_30_C(BOOST_PP_BOOL(p(31, s)), s, p, o, m)
#define BOOST_PP_FOR_31(s,p,o,m) BOOST_PP_FOR_31_C(BOOST_PP_BOOL(p(32, s)), s, p, o, m)
#define BOOST_PP_FOR_32(s,p,o,m) BOOST_PP_FOR_32_C(BOOST_PP_BOOL(p(33, s)), s, p, o, m)
#define BOOST_PP_FOR_33(s,p,o,m) BOOST_PP_FOR_33_C(BOOST_PP_BOOL(p(34, s)), s, p, o, m)
#define BOOST_PP_FOR_34(s,p,o,m) BOOST_PP_FOR_34_C(BOOST_PP_BOOL(p(35, s)), s, p, o, m)
#define BOOST_PP_FOR_35(s,p,o,m) BOOST_PP_FOR_35_C(BOOST_PP_BOOL(p(36, s)), s, p, o, m)
#define BOOST_PP_FOR_36(s,p,o,m) BOOST_PP_FOR_36_C(BOOST_PP_BOOL(p(37, s)), s, p, o, m)
#define BOOST_PP_FOR_37(s,p,o,m) BOOST_PP_FOR_37_C(BOOST_PP_BOOL(p(38, s)), s, p, o, m)
#define BOOST_PP_FOR_38(s,p,o,m) BOOST_PP_FOR_38_C(BOOST_PP_BOOL(p(39, s)), s, p, o, m)
#define BOOST_PP_FOR_39(s,p,o,m) BOOST_PP_FOR_39_C(BOOST_PP_BOOL(p(40, s)), s, p, o, m)
#define BOOST_PP_FOR_40(s,p,o,m) BOOST_PP_FOR_40_C(BOOST_PP_BOOL(p(41, s)), s, p, o, m)
#define BOOST_PP_FOR_41(s,p,o,m) BOOST_PP_FOR_41_C(BOOST_PP_BOOL(p(42, s)), s, p, o, m)
#define BOOST_PP_FOR_42(s,p,o,m) BOOST_PP_FOR_42_C(BOOST_PP_BOOL(p(43, s)), s, p, o, m)
#define BOOST_PP_FOR_43(s,p,o,m) BOOST_PP_FOR_43_C(BOOST_PP_BOOL(p(44, s)), s, p, o, m)
#define BOOST_PP_FOR_44(s,p,o,m) BOOST_PP_FOR_44_C(BOOST_PP_BOOL(p(45, s)), s, p, o, m)
#define BOOST_PP_FOR_45(s,p,o,m) BOOST_PP_FOR_45_C(BOOST_PP_BOOL(p(46, s)), s, p, o, m)
#define BOOST_PP_FOR_46(s,p,o,m) BOOST_PP_FOR_46_C(BOOST_PP_BOOL(p(47, s)), s, p, o, m)
#define BOOST_PP_FOR_47(s,p,o,m) BOOST_PP_FOR_47_C(BOOST_PP_BOOL(p(48, s)), s, p, o, m)
#define BOOST_PP_FOR_48(s,p,o,m) BOOST_PP_FOR_48_C(BOOST_PP_BOOL(p(49, s)), s, p, o, m)
#define BOOST_PP_FOR_49(s,p,o,m) BOOST_PP_FOR_49_C(BOOST_PP_BOOL(p(50, s)), s, p, o, m)
#define BOOST_PP_FOR_50(s,p,o,m) BOOST_PP_FOR_50_C(BOOST_PP_BOOL(p(51, s)), s, p, o, m)
#define BOOST_PP_FOR_51(s,p,o,m) BOOST_PP_FOR_51_C(BOOST_PP_BOOL(p(52, s)), s, p, o, m)
#define BOOST_PP_FOR_52(s,p,o,m) BOOST_PP_FOR_52_C(BOOST_PP_BOOL(p(53, s)), s, p, o, m)
#define BOOST_PP_FOR_53(s,p,o,m) BOOST_PP_FOR_53_C(BOOST_PP_BOOL(p(54, s)), s, p, o, m)
#define BOOST_PP_FOR_54(s,p,o,m) BOOST_PP_FOR_54_C(BOOST_PP_BOOL(p(55, s)), s, p, o, m)
#define BOOST_PP_FOR_55(s,p,o,m) BOOST_PP_FOR_55_C(BOOST_PP_BOOL(p(56, s)), s, p, o, m)
#define BOOST_PP_FOR_56(s,p,o,m) BOOST_PP_FOR_56_C(BOOST_PP_BOOL(p(57, s)), s, p, o, m)
#define BOOST_PP_FOR_57(s,p,o,m) BOOST_PP_FOR_57_C(BOOST_PP_BOOL(p(58, s)), s, p, o, m)
#define BOOST_PP_FOR_58(s,p,o,m) BOOST_PP_FOR_58_C(BOOST_PP_BOOL(p(59, s)), s, p, o, m)
#define BOOST_PP_FOR_59(s,p,o,m) BOOST_PP_FOR_59_C(BOOST_PP_BOOL(p(60, s)), s, p, o, m)
#define BOOST_PP_FOR_60(s,p,o,m) BOOST_PP_FOR_60_C(BOOST_PP_BOOL(p(61, s)), s, p, o, m)
#define BOOST_PP_FOR_61(s,p,o,m) BOOST_PP_FOR_61_C(BOOST_PP_BOOL(p(62, s)), s, p, o, m)
#define BOOST_PP_FOR_62(s,p,o,m) BOOST_PP_FOR_62_C(BOOST_PP_BOOL(p(63, s)), s, p, o, m)
#define BOOST_PP_FOR_63(s,p,o,m) BOOST_PP_FOR_63_C(BOOST_PP_BOOL(p(64, s)), s, p, o, m)
#define BOOST_PP_FOR_64(s,p,o,m) BOOST_PP_FOR_64_C(BOOST_PP_BOOL(p(65, s)), s, p, o, m)
#define BOOST_PP_FOR_65(s,p,o,m) BOOST_PP_FOR_65_C(BOOST_PP_BOOL(p(66, s)), s, p, o, m)
#define BOOST_PP_FOR_66(s,p,o,m) BOOST_PP_FOR_66_C(BOOST_PP_BOOL(p(67, s)), s, p, o, m)
#define BOOST_PP_FOR_67(s,p,o,m) BOOST_PP_FOR_67_C(BOOST_PP_BOOL(p(68, s)), s, p, o, m)
#define BOOST_PP_FOR_68(s,p,o,m) BOOST_PP_FOR_68_C(BOOST_PP_BOOL(p(69, s)), s, p, o, m)
#define BOOST_PP_FOR_69(s,p,o,m) BOOST_PP_FOR_69_C(BOOST_PP_BOOL(p(70, s)), s, p, o, m)
#define BOOST_PP_FOR_70(s,p,o,m) BOOST_PP_FOR_70_C(BOOST_PP_BOOL(p(71, s)), s, p, o, m)
#define BOOST_PP_FOR_71(s,p,o,m) BOOST_PP_FOR_71_C(BOOST_PP_BOOL(p(72, s)), s, p, o, m)
#define BOOST_PP_FOR_72(s,p,o,m) BOOST_PP_FOR_72_C(BOOST_PP_BOOL(p(73, s)), s, p, o, m)
#define BOOST_PP_FOR_73(s,p,o,m) BOOST_PP_FOR_73_C(BOOST_PP_BOOL(p(74, s)), s, p, o, m)
#define BOOST_PP_FOR_74(s,p,o,m) BOOST_PP_FOR_74_C(BOOST_PP_BOOL(p(75, s)), s, p, o, m)
#define BOOST_PP_FOR_75(s,p,o,m) BOOST_PP_FOR_75_C(BOOST_PP_BOOL(p(76, s)), s, p, o, m)
#define BOOST_PP_FOR_76(s,p,o,m) BOOST_PP_FOR_76_C(BOOST_PP_BOOL(p(77, s)), s, p, o, m)
#define BOOST_PP_FOR_77(s,p,o,m) BOOST_PP_FOR_77_C(BOOST_PP_BOOL(p(78, s)), s, p, o, m)
#define BOOST_PP_FOR_78(s,p,o,m) BOOST_PP_FOR_78_C(BOOST_PP_BOOL(p(79, s)), s, p, o, m)
#define BOOST_PP_FOR_79(s,p,o,m) BOOST_PP_FOR_79_C(BOOST_PP_BOOL(p(80, s)), s, p, o, m)
#define BOOST_PP_FOR_80(s,p,o,m) BOOST_PP_FOR_80_C(BOOST_PP_BOOL(p(81, s)), s, p, o, m)
#define BOOST_PP_FOR_81(s,p,o,m) BOOST_PP_FOR_81_C(BOOST_PP_BOOL(p(82, s)), s, p, o, m)
#define BOOST_PP_FOR_82(s,p,o,m) BOOST_PP_FOR_82_C(BOOST_PP_BOOL(p(83, s)), s, p, o, m)
#define BOOST_PP_FOR_83(s,p,o,m) BOOST_PP_FOR_83_C(BOOST_PP_BOOL(p(84, s)), s, p, o, m)
#define BOOST_PP_FOR_84(s,p,o,m) BOOST_PP_FOR_84_C(BOOST_PP_BOOL(p(85, s)), s, p, o, m)
#define BOOST_PP_FOR_85(s,p,o,m) BOOST_PP_FOR_85_C(BOOST_PP_BOOL(p(86, s)), s, p, o, m)
#define BOOST_PP_FOR_86(s,p,o,m) BOOST_PP_FOR_86_C(BOOST_PP_BOOL(p(87, s)), s, p, o, m)
#define BOOST_PP_FOR_87(s,p,o,m) BOOST_PP_FOR_87_C(BOOST_PP_BOOL(p(88, s)), s, p, o, m)
#define BOOST_PP_FOR_88(s,p,o,m) BOOST_PP_FOR_88_C(BOOST_PP_BOOL(p(89, s)), s, p, o, m)
#define BOOST_PP_FOR_89(s,p,o,m) BOOST_PP_FOR_89_C(BOOST_PP_BOOL(p(90, s)), s, p, o, m)
#define BOOST_PP_FOR_90(s,p,o,m) BOOST_PP_FOR_90_C(BOOST_PP_BOOL(p(91, s)), s, p, o, m)
#define BOOST_PP_FOR_91(s,p,o,m) BOOST_PP_FOR_91_C(BOOST_PP_BOOL(p(92, s)), s, p, o, m)
#define BOOST_PP_FOR_92(s,p,o,m) BOOST_PP_FOR_92_C(BOOST_PP_BOOL(p(93, s)), s, p, o, m)
#define BOOST_PP_FOR_93(s,p,o,m) BOOST_PP_FOR_93_C(BOOST_PP_BOOL(p(94, s)), s, p, o, m)
#define BOOST_PP_FOR_94(s,p,o,m) BOOST_PP_FOR_94_C(BOOST_PP_BOOL(p(95, s)), s, p, o, m)
#define BOOST_PP_FOR_95(s,p,o,m) BOOST_PP_FOR_95_C(BOOST_PP_BOOL(p(96, s)), s, p, o, m)
#define BOOST_PP_FOR_96(s,p,o,m) BOOST_PP_FOR_96_C(BOOST_PP_BOOL(p(97, s)), s, p, o, m)
#define BOOST_PP_FOR_97(s,p,o,m) BOOST_PP_FOR_97_C(BOOST_PP_BOOL(p(98, s)), s, p, o, m)
#define BOOST_PP_FOR_98(s,p,o,m) BOOST_PP_FOR_98_C(BOOST_PP_BOOL(p(99, s)), s, p, o, m)
#define BOOST_PP_FOR_99(s,p,o,m) BOOST_PP_FOR_99_C(BOOST_PP_BOOL(p(100, s)), s, p, o, m)
#define BOOST_PP_FOR_100(s,p,o,m) BOOST_PP_FOR_100_C(BOOST_PP_BOOL(p(101, s)), s, p, o, m)
#define BOOST_PP_FOR_101(s,p,o,m) BOOST_PP_FOR_101_C(BOOST_PP_BOOL(p(102, s)), s, p, o, m)
#define BOOST_PP_FOR_102(s,p,o,m) BOOST_PP_FOR_102_C(BOOST_PP_BOOL(p(103, s)), s, p, o, m)
#define BOOST_PP_FOR_103(s,p,o,m) BOOST_PP_FOR_103_C(BOOST_PP_BOOL(p(104, s)), s, p, o, m)
#define BOOST_PP_FOR_104(s,p,o,m) BOOST_PP_FOR_104_C(BOOST_PP_BOOL(p(105, s)), s, p, o, m)
#define BOOST_PP_FOR_105(s,p,o,m) BOOST_PP_FOR_105_C(BOOST_PP_BOOL(p(106, s)), s, p, o, m)
#define BOOST_PP_FOR_106(s,p,o,m) BOOST_PP_FOR_106_C(BOOST_PP_BOOL(p(107, s)), s, p, o, m)
#define BOOST_PP_FOR_107(s,p,o,m) BOOST_PP_FOR_107_C(BOOST_PP_BOOL(p(108, s)), s, p, o, m)
#define BOOST_PP_FOR_108(s,p,o,m) BOOST_PP_FOR_108_C(BOOST_PP_BOOL(p(109, s)), s, p, o, m)
#define BOOST_PP_FOR_109(s,p,o,m) BOOST_PP_FOR_109_C(BOOST_PP_BOOL(p(110, s)), s, p, o, m)
#define BOOST_PP_FOR_110(s,p,o,m) BOOST_PP_FOR_110_C(BOOST_PP_BOOL(p(111, s)), s, p, o, m)
#define BOOST_PP_FOR_111(s,p,o,m) BOOST_PP_FOR_111_C(BOOST_PP_BOOL(p(112, s)), s, p, o, m)
#define BOOST_PP_FOR_112(s,p,o,m) BOOST_PP_FOR_112_C(BOOST_PP_BOOL(p(113, s)), s, p, o, m)
#define BOOST_PP_FOR_113(s,p,o,m) BOOST_PP_FOR_113_C(BOOST_PP_BOOL(p(114, s)), s, p, o, m)
#define BOOST_PP_FOR_114(s,p,o,m) BOOST_PP_FOR_114_C(BOOST_PP_BOOL(p(115, s)), s, p, o, m)
#define BOOST_PP_FOR_115(s,p,o,m) BOOST_PP_FOR_115_C(BOOST_PP_BOOL(p(116, s)), s, p, o, m)
#define BOOST_PP_FOR_116(s,p,o,m) BOOST_PP_FOR_116_C(BOOST_PP_BOOL(p(117, s)), s, p, o, m)
#define BOOST_PP_FOR_117(s,p,o,m) BOOST_PP_FOR_117_C(BOOST_PP_BOOL(p(118, s)), s, p, o, m)
#define BOOST_PP_FOR_118(s,p,o,m) BOOST_PP_FOR_118_C(BOOST_PP_BOOL(p(119, s)), s, p, o, m)
#define BOOST_PP_FOR_119(s,p,o,m) BOOST_PP_FOR_119_C(BOOST_PP_BOOL(p(120, s)), s, p, o, m)
#define BOOST_PP_FOR_120(s,p,o,m) BOOST_PP_FOR_120_C(BOOST_PP_BOOL(p(121, s)), s, p, o, m)
#define BOOST_PP_FOR_121(s,p,o,m) BOOST_PP_FOR_121_C(BOOST_PP_BOOL(p(122, s)), s, p, o, m)
#define BOOST_PP_FOR_122(s,p,o,m) BOOST_PP_FOR_122_C(BOOST_PP_BOOL(p(123, s)), s, p, o, m)
#define BOOST_PP_FOR_123(s,p,o,m) BOOST_PP_FOR_123_C(BOOST_PP_BOOL(p(124, s)), s, p, o, m)
#define BOOST_PP_FOR_124(s,p,o,m) BOOST_PP_FOR_124_C(BOOST_PP_BOOL(p(125, s)), s, p, o, m)
#define BOOST_PP_FOR_125(s,p,o,m) BOOST_PP_FOR_125_C(BOOST_PP_BOOL(p(126, s)), s, p, o, m)
#define BOOST_PP_FOR_126(s,p,o,m) BOOST_PP_FOR_126_C(BOOST_PP_BOOL(p(127, s)), s, p, o, m)
#define BOOST_PP_FOR_127(s,p,o,m) BOOST_PP_FOR_127_C(BOOST_PP_BOOL(p(128, s)), s, p, o, m)
#define BOOST_PP_FOR_128(s,p,o,m) BOOST_PP_FOR_128_C(BOOST_PP_BOOL(p(129, s)), s, p, o, m)
#define BOOST_PP_FOR_129(s,p,o,m) BOOST_PP_FOR_129_C(BOOST_PP_BOOL(p(130, s)), s, p, o, m)
#define BOOST_PP_FOR_130(s,p,o,m) BOOST_PP_FOR_130_C(BOOST_PP_BOOL(p(131, s)), s, p, o, m)
#define BOOST_PP_FOR_131(s,p,o,m) BOOST_PP_FOR_131_C(BOOST_PP_BOOL(p(132, s)), s, p, o, m)
#define BOOST_PP_FOR_132(s,p,o,m) BOOST_PP_FOR_132_C(BOOST_PP_BOOL(p(133, s)), s, p, o, m)
#define BOOST_PP_FOR_133(s,p,o,m) BOOST_PP_FOR_133_C(BOOST_PP_BOOL(p(134, s)), s, p, o, m)
#define BOOST_PP_FOR_134(s,p,o,m) BOOST_PP_FOR_134_C(BOOST_PP_BOOL(p(135, s)), s, p, o, m)
#define BOOST_PP_FOR_135(s,p,o,m) BOOST_PP_FOR_135_C(BOOST_PP_BOOL(p(136, s)), s, p, o, m)
#define BOOST_PP_FOR_136(s,p,o,m) BOOST_PP_FOR_136_C(BOOST_PP_BOOL(p(137, s)), s, p, o, m)
#define BOOST_PP_FOR_137(s,p,o,m) BOOST_PP_FOR_137_C(BOOST_PP_BOOL(p(138, s)), s, p, o, m)
#define BOOST_PP_FOR_138(s,p,o,m) BOOST_PP_FOR_138_C(BOOST_PP_BOOL(p(139, s)), s, p, o, m)
#define BOOST_PP_FOR_139(s,p,o,m) BOOST_PP_FOR_139_C(BOOST_PP_BOOL(p(140, s)), s, p, o, m)
#define BOOST_PP_FOR_140(s,p,o,m) BOOST_PP_FOR_140_C(BOOST_PP_BOOL(p(141, s)), s, p, o, m)
#define BOOST_PP_FOR_141(s,p,o,m) BOOST_PP_FOR_141_C(BOOST_PP_BOOL(p(142, s)), s, p, o, m)
#define BOOST_PP_FOR_142(s,p,o,m) BOOST_PP_FOR_142_C(BOOST_PP_BOOL(p(143, s)), s, p, o, m)
#define BOOST_PP_FOR_143(s,p,o,m) BOOST_PP_FOR_143_C(BOOST_PP_BOOL(p(144, s)), s, p, o, m)
#define BOOST_PP_FOR_144(s,p,o,m) BOOST_PP_FOR_144_C(BOOST_PP_BOOL(p(145, s)), s, p, o, m)
#define BOOST_PP_FOR_145(s,p,o,m) BOOST_PP_FOR_145_C(BOOST_PP_BOOL(p(146, s)), s, p, o, m)
#define BOOST_PP_FOR_146(s,p,o,m) BOOST_PP_FOR_146_C(BOOST_PP_BOOL(p(147, s)), s, p, o, m)
#define BOOST_PP_FOR_147(s,p,o,m) BOOST_PP_FOR_147_C(BOOST_PP_BOOL(p(148, s)), s, p, o, m)
#define BOOST_PP_FOR_148(s,p,o,m) BOOST_PP_FOR_148_C(BOOST_PP_BOOL(p(149, s)), s, p, o, m)
#define BOOST_PP_FOR_149(s,p,o,m) BOOST_PP_FOR_149_C(BOOST_PP_BOOL(p(150, s)), s, p, o, m)
#define BOOST_PP_FOR_150(s,p,o,m) BOOST_PP_FOR_150_C(BOOST_PP_BOOL(p(151, s)), s, p, o, m)
#define BOOST_PP_FOR_151(s,p,o,m) BOOST_PP_FOR_151_C(BOOST_PP_BOOL(p(152, s)), s, p, o, m)
#define BOOST_PP_FOR_152(s,p,o,m) BOOST_PP_FOR_152_C(BOOST_PP_BOOL(p(153, s)), s, p, o, m)
#define BOOST_PP_FOR_153(s,p,o,m) BOOST_PP_FOR_153_C(BOOST_PP_BOOL(p(154, s)), s, p, o, m)
#define BOOST_PP_FOR_154(s,p,o,m) BOOST_PP_FOR_154_C(BOOST_PP_BOOL(p(155, s)), s, p, o, m)
#define BOOST_PP_FOR_155(s,p,o,m) BOOST_PP_FOR_155_C(BOOST_PP_BOOL(p(156, s)), s, p, o, m)
#define BOOST_PP_FOR_156(s,p,o,m) BOOST_PP_FOR_156_C(BOOST_PP_BOOL(p(157, s)), s, p, o, m)
#define BOOST_PP_FOR_157(s,p,o,m) BOOST_PP_FOR_157_C(BOOST_PP_BOOL(p(158, s)), s, p, o, m)
#define BOOST_PP_FOR_158(s,p,o,m) BOOST_PP_FOR_158_C(BOOST_PP_BOOL(p(159, s)), s, p, o, m)
#define BOOST_PP_FOR_159(s,p,o,m) BOOST_PP_FOR_159_C(BOOST_PP_BOOL(p(160, s)), s, p, o, m)
#define BOOST_PP_FOR_160(s,p,o,m) BOOST_PP_FOR_160_C(BOOST_PP_BOOL(p(161, s)), s, p, o, m)
#define BOOST_PP_FOR_161(s,p,o,m) BOOST_PP_FOR_161_C(BOOST_PP_BOOL(p(162, s)), s, p, o, m)
#define BOOST_PP_FOR_162(s,p,o,m) BOOST_PP_FOR_162_C(BOOST_PP_BOOL(p(163, s)), s, p, o, m)
#define BOOST_PP_FOR_163(s,p,o,m) BOOST_PP_FOR_163_C(BOOST_PP_BOOL(p(164, s)), s, p, o, m)
#define BOOST_PP_FOR_164(s,p,o,m) BOOST_PP_FOR_164_C(BOOST_PP_BOOL(p(165, s)), s, p, o, m)
#define BOOST_PP_FOR_165(s,p,o,m) BOOST_PP_FOR_165_C(BOOST_PP_BOOL(p(166, s)), s, p, o, m)
#define BOOST_PP_FOR_166(s,p,o,m) BOOST_PP_FOR_166_C(BOOST_PP_BOOL(p(167, s)), s, p, o, m)
#define BOOST_PP_FOR_167(s,p,o,m) BOOST_PP_FOR_167_C(BOOST_PP_BOOL(p(168, s)), s, p, o, m)
#define BOOST_PP_FOR_168(s,p,o,m) BOOST_PP_FOR_168_C(BOOST_PP_BOOL(p(169, s)), s, p, o, m)
#define BOOST_PP_FOR_169(s,p,o,m) BOOST_PP_FOR_169_C(BOOST_PP_BOOL(p(170, s)), s, p, o, m)
#define BOOST_PP_FOR_170(s,p,o,m) BOOST_PP_FOR_170_C(BOOST_PP_BOOL(p(171, s)), s, p, o, m)
#define BOOST_PP_FOR_171(s,p,o,m) BOOST_PP_FOR_171_C(BOOST_PP_BOOL(p(172, s)), s, p, o, m)
#define BOOST_PP_FOR_172(s,p,o,m) BOOST_PP_FOR_172_C(BOOST_PP_BOOL(p(173, s)), s, p, o, m)
#define BOOST_PP_FOR_173(s,p,o,m) BOOST_PP_FOR_173_C(BOOST_PP_BOOL(p(174, s)), s, p, o, m)
#define BOOST_PP_FOR_174(s,p,o,m) BOOST_PP_FOR_174_C(BOOST_PP_BOOL(p(175, s)), s, p, o, m)
#define BOOST_PP_FOR_175(s,p,o,m) BOOST_PP_FOR_175_C(BOOST_PP_BOOL(p(176, s)), s, p, o, m)
#define BOOST_PP_FOR_176(s,p,o,m) BOOST_PP_FOR_176_C(BOOST_PP_BOOL(p(177, s)), s, p, o, m)
#define BOOST_PP_FOR_177(s,p,o,m) BOOST_PP_FOR_177_C(BOOST_PP_BOOL(p(178, s)), s, p, o, m)
#define BOOST_PP_FOR_178(s,p,o,m) BOOST_PP_FOR_178_C(BOOST_PP_BOOL(p(179, s)), s, p, o, m)
#define BOOST_PP_FOR_179(s,p,o,m) BOOST_PP_FOR_179_C(BOOST_PP_BOOL(p(180, s)), s, p, o, m)
#define BOOST_PP_FOR_180(s,p,o,m) BOOST_PP_FOR_180_C(BOOST_PP_BOOL(p(181, s)), s, p, o, m)
#define BOOST_PP_FOR_181(s,p,o,m) BOOST_PP_FOR_181_C(BOOST_PP_BOOL(p(182, s)), s, p, o, m)
#define BOOST_PP_FOR_182(s,p,o,m) BOOST_PP_FOR_182_C(BOOST_PP_BOOL(p(183, s)), s, p, o, m)
#define BOOST_PP_FOR_183(s,p,o,m) BOOST_PP_FOR_183_C(BOOST_PP_BOOL(p(184, s)), s, p, o, m)
#define BOOST_PP_FOR_184(s,p,o,m) BOOST_PP_FOR_184_C(BOOST_PP_BOOL(p(185, s)), s, p, o, m)
#define BOOST_PP_FOR_185(s,p,o,m) BOOST_PP_FOR_185_C(BOOST_PP_BOOL(p(186, s)), s, p, o, m)
#define BOOST_PP_FOR_186(s,p,o,m) BOOST_PP_FOR_186_C(BOOST_PP_BOOL(p(187, s)), s, p, o, m)
#define BOOST_PP_FOR_187(s,p,o,m) BOOST_PP_FOR_187_C(BOOST_PP_BOOL(p(188, s)), s, p, o, m)
#define BOOST_PP_FOR_188(s,p,o,m) BOOST_PP_FOR_188_C(BOOST_PP_BOOL(p(189, s)), s, p, o, m)
#define BOOST_PP_FOR_189(s,p,o,m) BOOST_PP_FOR_189_C(BOOST_PP_BOOL(p(190, s)), s, p, o, m)
#define BOOST_PP_FOR_190(s,p,o,m) BOOST_PP_FOR_190_C(BOOST_PP_BOOL(p(191, s)), s, p, o, m)
#define BOOST_PP_FOR_191(s,p,o,m) BOOST_PP_FOR_191_C(BOOST_PP_BOOL(p(192, s)), s, p, o, m)
#define BOOST_PP_FOR_192(s,p,o,m) BOOST_PP_FOR_192_C(BOOST_PP_BOOL(p(193, s)), s, p, o, m)
#define BOOST_PP_FOR_193(s,p,o,m) BOOST_PP_FOR_193_C(BOOST_PP_BOOL(p(194, s)), s, p, o, m)
#define BOOST_PP_FOR_194(s,p,o,m) BOOST_PP_FOR_194_C(BOOST_PP_BOOL(p(195, s)), s, p, o, m)
#define BOOST_PP_FOR_195(s,p,o,m) BOOST_PP_FOR_195_C(BOOST_PP_BOOL(p(196, s)), s, p, o, m)
#define BOOST_PP_FOR_196(s,p,o,m) BOOST_PP_FOR_196_C(BOOST_PP_BOOL(p(197, s)), s, p, o, m)
#define BOOST_PP_FOR_197(s,p,o,m) BOOST_PP_FOR_197_C(BOOST_PP_BOOL(p(198, s)), s, p, o, m)
#define BOOST_PP_FOR_198(s,p,o,m) BOOST_PP_FOR_198_C(BOOST_PP_BOOL(p(199, s)), s, p, o, m)
#define BOOST_PP_FOR_199(s,p,o,m) BOOST_PP_FOR_199_C(BOOST_PP_BOOL(p(200, s)), s, p, o, m)
#define BOOST_PP_FOR_200(s,p,o,m) BOOST_PP_FOR_200_C(BOOST_PP_BOOL(p(201, s)), s, p, o, m)
#define BOOST_PP_FOR_201(s,p,o,m) BOOST_PP_FOR_201_C(BOOST_PP_BOOL(p(202, s)), s, p, o, m)
#define BOOST_PP_FOR_202(s,p,o,m) BOOST_PP_FOR_202_C(BOOST_PP_BOOL(p(203, s)), s, p, o, m)
#define BOOST_PP_FOR_203(s,p,o,m) BOOST_PP_FOR_203_C(BOOST_PP_BOOL(p(204, s)), s, p, o, m)
#define BOOST_PP_FOR_204(s,p,o,m) BOOST_PP_FOR_204_C(BOOST_PP_BOOL(p(205, s)), s, p, o, m)
#define BOOST_PP_FOR_205(s,p,o,m) BOOST_PP_FOR_205_C(BOOST_PP_BOOL(p(206, s)), s, p, o, m)
#define BOOST_PP_FOR_206(s,p,o,m) BOOST_PP_FOR_206_C(BOOST_PP_BOOL(p(207, s)), s, p, o, m)
#define BOOST_PP_FOR_207(s,p,o,m) BOOST_PP_FOR_207_C(BOOST_PP_BOOL(p(208, s)), s, p, o, m)
#define BOOST_PP_FOR_208(s,p,o,m) BOOST_PP_FOR_208_C(BOOST_PP_BOOL(p(209, s)), s, p, o, m)
#define BOOST_PP_FOR_209(s,p,o,m) BOOST_PP_FOR_209_C(BOOST_PP_BOOL(p(210, s)), s, p, o, m)
#define BOOST_PP_FOR_210(s,p,o,m) BOOST_PP_FOR_210_C(BOOST_PP_BOOL(p(211, s)), s, p, o, m)
#define BOOST_PP_FOR_211(s,p,o,m) BOOST_PP_FOR_211_C(BOOST_PP_BOOL(p(212, s)), s, p, o, m)
#define BOOST_PP_FOR_212(s,p,o,m) BOOST_PP_FOR_212_C(BOOST_PP_BOOL(p(213, s)), s, p, o, m)
#define BOOST_PP_FOR_213(s,p,o,m) BOOST_PP_FOR_213_C(BOOST_PP_BOOL(p(214, s)), s, p, o, m)
#define BOOST_PP_FOR_214(s,p,o,m) BOOST_PP_FOR_214_C(BOOST_PP_BOOL(p(215, s)), s, p, o, m)
#define BOOST_PP_FOR_215(s,p,o,m) BOOST_PP_FOR_215_C(BOOST_PP_BOOL(p(216, s)), s, p, o, m)
#define BOOST_PP_FOR_216(s,p,o,m) BOOST_PP_FOR_216_C(BOOST_PP_BOOL(p(217, s)), s, p, o, m)
#define BOOST_PP_FOR_217(s,p,o,m) BOOST_PP_FOR_217_C(BOOST_PP_BOOL(p(218, s)), s, p, o, m)
#define BOOST_PP_FOR_218(s,p,o,m) BOOST_PP_FOR_218_C(BOOST_PP_BOOL(p(219, s)), s, p, o, m)
#define BOOST_PP_FOR_219(s,p,o,m) BOOST_PP_FOR_219_C(BOOST_PP_BOOL(p(220, s)), s, p, o, m)
#define BOOST_PP_FOR_220(s,p,o,m) BOOST_PP_FOR_220_C(BOOST_PP_BOOL(p(221, s)), s, p, o, m)
#define BOOST_PP_FOR_221(s,p,o,m) BOOST_PP_FOR_221_C(BOOST_PP_BOOL(p(222, s)), s, p, o, m)
#define BOOST_PP_FOR_222(s,p,o,m) BOOST_PP_FOR_222_C(BOOST_PP_BOOL(p(223, s)), s, p, o, m)
#define BOOST_PP_FOR_223(s,p,o,m) BOOST_PP_FOR_223_C(BOOST_PP_BOOL(p(224, s)), s, p, o, m)
#define BOOST_PP_FOR_224(s,p,o,m) BOOST_PP_FOR_224_C(BOOST_PP_BOOL(p(225, s)), s, p, o, m)
#define BOOST_PP_FOR_225(s,p,o,m) BOOST_PP_FOR_225_C(BOOST_PP_BOOL(p(226, s)), s, p, o, m)
#define BOOST_PP_FOR_226(s,p,o,m) BOOST_PP_FOR_226_C(BOOST_PP_BOOL(p(227, s)), s, p, o, m)
#define BOOST_PP_FOR_227(s,p,o,m) BOOST_PP_FOR_227_C(BOOST_PP_BOOL(p(228, s)), s, p, o, m)
#define BOOST_PP_FOR_228(s,p,o,m) BOOST_PP_FOR_228_C(BOOST_PP_BOOL(p(229, s)), s, p, o, m)
#define BOOST_PP_FOR_229(s,p,o,m) BOOST_PP_FOR_229_C(BOOST_PP_BOOL(p(230, s)), s, p, o, m)
#define BOOST_PP_FOR_230(s,p,o,m) BOOST_PP_FOR_230_C(BOOST_PP_BOOL(p(231, s)), s, p, o, m)
#define BOOST_PP_FOR_231(s,p,o,m) BOOST_PP_FOR_231_C(BOOST_PP_BOOL(p(232, s)), s, p, o, m)
#define BOOST_PP_FOR_232(s,p,o,m) BOOST_PP_FOR_232_C(BOOST_PP_BOOL(p(233, s)), s, p, o, m)
#define BOOST_PP_FOR_233(s,p,o,m) BOOST_PP_FOR_233_C(BOOST_PP_BOOL(p(234, s)), s, p, o, m)
#define BOOST_PP_FOR_234(s,p,o,m) BOOST_PP_FOR_234_C(BOOST_PP_BOOL(p(235, s)), s, p, o, m)
#define BOOST_PP_FOR_235(s,p,o,m) BOOST_PP_FOR_235_C(BOOST_PP_BOOL(p(236, s)), s, p, o, m)
#define BOOST_PP_FOR_236(s,p,o,m) BOOST_PP_FOR_236_C(BOOST_PP_BOOL(p(237, s)), s, p, o, m)
#define BOOST_PP_FOR_237(s,p,o,m) BOOST_PP_FOR_237_C(BOOST_PP_BOOL(p(238, s)), s, p, o, m)
#define BOOST_PP_FOR_238(s,p,o,m) BOOST_PP_FOR_238_C(BOOST_PP_BOOL(p(239, s)), s, p, o, m)
#define BOOST_PP_FOR_239(s,p,o,m) BOOST_PP_FOR_239_C(BOOST_PP_BOOL(p(240, s)), s, p, o, m)
#define BOOST_PP_FOR_240(s,p,o,m) BOOST_PP_FOR_240_C(BOOST_PP_BOOL(p(241, s)), s, p, o, m)
#define BOOST_PP_FOR_241(s,p,o,m) BOOST_PP_FOR_241_C(BOOST_PP_BOOL(p(242, s)), s, p, o, m)
#define BOOST_PP_FOR_242(s,p,o,m) BOOST_PP_FOR_242_C(BOOST_PP_BOOL(p(243, s)), s, p, o, m)
#define BOOST_PP_FOR_243(s,p,o,m) BOOST_PP_FOR_243_C(BOOST_PP_BOOL(p(244, s)), s, p, o, m)
#define BOOST_PP_FOR_244(s,p,o,m) BOOST_PP_FOR_244_C(BOOST_PP_BOOL(p(245, s)), s, p, o, m)
#define BOOST_PP_FOR_245(s,p,o,m) BOOST_PP_FOR_245_C(BOOST_PP_BOOL(p(246, s)), s, p, o, m)
#define BOOST_PP_FOR_246(s,p,o,m) BOOST_PP_FOR_246_C(BOOST_PP_BOOL(p(247, s)), s, p, o, m)
#define BOOST_PP_FOR_247(s,p,o,m) BOOST_PP_FOR_247_C(BOOST_PP_BOOL(p(248, s)), s, p, o, m)
#define BOOST_PP_FOR_248(s,p,o,m) BOOST_PP_FOR_248_C(BOOST_PP_BOOL(p(249, s)), s, p, o, m)
#define BOOST_PP_FOR_249(s,p,o,m) BOOST_PP_FOR_249_C(BOOST_PP_BOOL(p(250, s)), s, p, o, m)
#define BOOST_PP_FOR_250(s,p,o,m) BOOST_PP_FOR_250_C(BOOST_PP_BOOL(p(251, s)), s, p, o, m)
#define BOOST_PP_FOR_251(s,p,o,m) BOOST_PP_FOR_251_C(BOOST_PP_BOOL(p(252, s)), s, p, o, m)
#define BOOST_PP_FOR_252(s,p,o,m) BOOST_PP_FOR_252_C(BOOST_PP_BOOL(p(253, s)), s, p, o, m)
#define BOOST_PP_FOR_253(s,p,o,m) BOOST_PP_FOR_253_C(BOOST_PP_BOOL(p(254, s)), s, p, o, m)
#define BOOST_PP_FOR_254(s,p,o,m) BOOST_PP_FOR_254_C(BOOST_PP_BOOL(p(255, s)), s, p, o, m)
#define BOOST_PP_FOR_255(s,p,o,m) BOOST_PP_FOR_255_C(BOOST_PP_BOOL(p(256, s)), s, p, o, m)
#define BOOST_PP_FOR_256(s,p,o,m) BOOST_PP_FOR_256_C(BOOST_PP_BOOL(p(257, s)), s, p, o, m)

#define BOOST_PP_FOR_1_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IIF(c, BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(2, s), p, o, m)
#define BOOST_PP_FOR_2_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IIF(c, BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(3, s), p, o, m)
#define BOOST_PP_FOR_3_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IIF(c, BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(4, s), p, o, m)
#define BOOST_PP_FOR_4_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IIF(c, BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(5, s), p, o, m)
#define BOOST_PP_FOR_5_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IIF(c, BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(6, s), p, o, m)
#define BOOST_PP_FOR_6_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IIF(c, BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(7, s), p, o, m)
#define BOOST_PP_FOR_7_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IIF(c, BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(8, s), p, o, m)
#define BOOST_PP_FOR_8_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IIF(c, BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(9, s), p, o, m)
#define BOOST_PP_FOR_9_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IIF(c, BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(10, s), p, o, m)
#define BOOST_PP_FOR_10_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IIF(c, BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(11, s), p, o, m)
#define BOOST_PP_FOR_11_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IIF(c, BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(12, s), p, o, m)
#define BOOST_PP_FOR_12_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IIF(c, BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(13, s), p, o, m)
#define BOOST_PP_FOR_13_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IIF(c, BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(14, s), p, o, m)
#define BOOST_PP_FOR_14_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IIF(c, BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(15, s), p, o, m)
#define BOOST_PP_FOR_15_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IIF(c, BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(16, s), p, o, m)
#define BOOST_PP_FOR_16_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IIF(c, BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(17, s), p, o, m)
#define BOOST_PP_FOR_17_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IIF(c, BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(18, s), p, o, m)
#define BOOST_PP_FOR_18_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IIF(c, BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(19, s), p, o, m)
#define BOOST_PP_FOR_19_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IIF(c, BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(20, s), p, o, m)
#define BOOST_PP_FOR_20_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IIF(c, BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(21, s), p, o, m)
#define BOOST_PP_FOR_21_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IIF(c, BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(22, s), p, o, m)
#define BOOST_PP_FOR_22_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IIF(c, BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(23, s), p, o, m)
#define BOOST_PP_FOR_23_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IIF(c, BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(24, s), p, o, m)
#define BOOST_PP_FOR_24_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IIF(c, BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(25, s), p, o, m)
#define BOOST_PP_FOR_25_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IIF(c, BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(26, s), p, o, m)
#define BOOST_PP_FOR_26_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IIF(c, BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(27, s), p, o, m)
#define BOOST_PP_FOR_27_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IIF(c, BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(28, s), p, o, m)
#define BOOST_PP_FOR_28_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IIF(c, BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(29, s), p, o, m)
#define BOOST_PP_FOR_29_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IIF(c, BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(30, s), p, o, m)
#define BOOST_PP_FOR_30_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IIF(c, BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(31, s), p, o, m)
#define BOOST_PP_FOR_31_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IIF(c, BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(32, s), p, o, m)
#define BOOST_PP_FOR_32_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IIF(c, BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(33, s), p, o, m)
#define BOOST_PP_FOR_33_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IIF(c, BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(34, s), p, o, m)
#define BOOST_PP_FOR_34_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IIF(c, BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(35, s), p, o, m)
#define BOOST_PP_FOR_35_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IIF(c, BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(36, s), p, o, m)
#define BOOST_PP_FOR_36_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IIF(c, BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(37, s), p, o, m)
#define BOOST_PP_FOR_37_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IIF(c, BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(38, s), p, o, m)
#define BOOST_PP_FOR_38_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IIF(c, BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(39, s), p, o, m)
#define BOOST_PP_FOR_39_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IIF(c, BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(40, s), p, o, m)
#define BOOST_PP_FOR_40_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IIF(c, BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(41, s), p, o, m)
#define BOOST_PP_FOR_41_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IIF(c, BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(42, s), p, o, m)
#define BOOST_PP_FOR_42_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IIF(c, BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(43, s), p, o, m)
#define BOOST_PP_FOR_43_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IIF(c, BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(44, s), p, o, m)
#define BOOST_PP_FOR_44_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IIF(c, BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(45, s), p, o, m)
#define BOOST_PP_FOR_45_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IIF(c, BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(46, s), p, o, m)
#define BOOST_PP_FOR_46_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IIF(c, BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(47, s), p, o, m)
#define BOOST_PP_FOR_47_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IIF(c, BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(48, s), p, o, m)
#define BOOST_PP_FOR_48_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IIF(c, BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(49, s), p, o, m)
#define BOOST_PP_FOR_49_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IIF(c, BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(50, s), p, o, m)
#define BOOST_PP_FOR_50_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IIF(c, BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(51, s), p, o, m)
#define BOOST_PP_FOR_51_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IIF(c, BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(52, s), p, o, m)
#define BOOST_PP_FOR_52_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IIF(c, BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(53, s), p, o, m)
#define BOOST_PP_FOR_53_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IIF(c, BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(54, s), p, o, m)
#define BOOST_PP_FOR_54_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IIF(c, BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(55, s), p, o, m)
#define BOOST_PP_FOR_55_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IIF(c, BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(56, s), p, o, m)
#define BOOST_PP_FOR_56_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IIF(c, BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(57, s), p, o, m)
#define BOOST_PP_FOR_57_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IIF(c, BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(58, s), p, o, m)
#define BOOST_PP_FOR_58_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IIF(c, BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(59, s), p, o, m)
#define BOOST_PP_FOR_59_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IIF(c, BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(60, s), p, o, m)
#define BOOST_PP_FOR_60_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IIF(c, BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(61, s), p, o, m)
#define BOOST_PP_FOR_61_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IIF(c, BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(62, s), p, o, m)
#define BOOST_PP_FOR_62_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IIF(c, BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(63, s), p, o, m)
#define BOOST_PP_FOR_63_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IIF(c, BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(64, s), p, o, m)
#define BOOST_PP_FOR_64_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IIF(c, BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(65, s), p, o, m)
#define BOOST_PP_FOR_65_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IIF(c, BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(66, s), p, o, m)
#define BOOST_PP_FOR_66_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IIF(c, BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(67, s), p, o, m)
#define BOOST_PP_FOR_67_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IIF(c, BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(68, s), p, o, m)
#define BOOST_PP_FOR_68_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IIF(c, BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(69, s), p, o, m)
#define BOOST_PP_FOR_69_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IIF(c, BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(70, s), p, o, m)
#define BOOST_PP_FOR_70_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IIF(c, BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(71, s), p, o, m)
#define BOOST_PP_FOR_71_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IIF(c, BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(72, s), p, o, m)
#define BOOST_PP_FOR_72_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IIF(c, BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(73, s), p, o, m)
#define BOOST_PP_FOR_73_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IIF(c, BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(74, s), p, o, m)
#define BOOST_PP_FOR_74_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IIF(c, BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(75, s), p, o, m)
#define BOOST_PP_FOR_75_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IIF(c, BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(76, s), p, o, m)
#define BOOST_PP_FOR_76_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IIF(c, BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(77, s), p, o, m)
#define BOOST_PP_FOR_77_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IIF(c, BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(78, s), p, o, m)
#define BOOST_PP_FOR_78_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IIF(c, BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(79, s), p, o, m)
#define BOOST_PP_FOR_79_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IIF(c, BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(80, s), p, o, m)
#define BOOST_PP_FOR_80_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IIF(c, BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(81, s), p, o, m)
#define BOOST_PP_FOR_81_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IIF(c, BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(82, s), p, o, m)
#define BOOST_PP_FOR_82_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IIF(c, BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(83, s), p, o, m)
#define BOOST_PP_FOR_83_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IIF(c, BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(84, s), p, o, m)
#define BOOST_PP_FOR_84_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IIF(c, BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(85, s), p, o, m)
#define BOOST_PP_FOR_85_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IIF(c, BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(86, s), p, o, m)
#define BOOST_PP_FOR_86_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IIF(c, BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(87, s), p, o, m)
#define BOOST_PP_FOR_87_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IIF(c, BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(88, s), p, o, m)
#define BOOST_PP_FOR_88_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IIF(c, BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(89, s), p, o, m)
#define BOOST_PP_FOR_89_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IIF(c, BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(90, s), p, o, m)
#define BOOST_PP_FOR_90_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IIF(c, BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(91, s), p, o, m)
#define BOOST_PP_FOR_91_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IIF(c, BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(92, s), p, o, m)
#define BOOST_PP_FOR_92_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IIF(c, BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(93, s), p, o, m)
#define BOOST_PP_FOR_93_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IIF(c, BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(94, s), p, o, m)
#define BOOST_PP_FOR_94_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IIF(c, BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(95, s), p, o, m)
#define BOOST_PP_FOR_95_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IIF(c, BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(96, s), p, o, m)
#define BOOST_PP_FOR_96_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IIF(c, BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(97, s), p, o, m)
#define BOOST_PP_FOR_97_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IIF(c, BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(98, s), p, o, m)
#define BOOST_PP_FOR_98_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IIF(c, BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(99, s), p, o, m)
#define BOOST_PP_FOR_99_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IIF(c, BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(100, s), p, o, m)
#define BOOST_PP_FOR_100_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IIF(c, BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(101, s), p, o, m)
#define BOOST_PP_FOR_101_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IIF(c, BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(102, s), p, o, m)
#define BOOST_PP_FOR_102_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IIF(c, BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(103, s), p, o, m)
#define BOOST_PP_FOR_103_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IIF(c, BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(104, s), p, o, m)
#define BOOST_PP_FOR_104_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IIF(c, BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(105, s), p, o, m)
#define BOOST_PP_FOR_105_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IIF(c, BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(106, s), p, o, m)
#define BOOST_PP_FOR_106_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IIF(c, BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(107, s), p, o, m)
#define BOOST_PP_FOR_107_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IIF(c, BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(108, s), p, o, m)
#define BOOST_PP_FOR_108_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IIF(c, BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(109, s), p, o, m)
#define BOOST_PP_FOR_109_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IIF(c, BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(110, s), p, o, m)
#define BOOST_PP_FOR_110_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IIF(c, BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(111, s), p, o, m)
#define BOOST_PP_FOR_111_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IIF(c, BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(112, s), p, o, m)
#define BOOST_PP_FOR_112_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IIF(c, BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(113, s), p, o, m)
#define BOOST_PP_FOR_113_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IIF(c, BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(114, s), p, o, m)
#define BOOST_PP_FOR_114_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IIF(c, BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(115, s), p, o, m)
#define BOOST_PP_FOR_115_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IIF(c, BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(116, s), p, o, m)
#define BOOST_PP_FOR_116_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IIF(c, BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(117, s), p, o, m)
#define BOOST_PP_FOR_117_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IIF(c, BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(118, s), p, o, m)
#define BOOST_PP_FOR_118_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IIF(c, BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(119, s), p, o, m)
#define BOOST_PP_FOR_119_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IIF(c, BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(120, s), p, o, m)
#define BOOST_PP_FOR_120_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IIF(c, BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(121, s), p, o, m)
#define BOOST_PP_FOR_121_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IIF(c, BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(122, s), p, o, m)
#define BOOST_PP_FOR_122_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IIF(c, BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(123, s), p, o, m)
#define BOOST_PP_FOR_123_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IIF(c, BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(124, s), p, o, m)
#define BOOST_PP_FOR_124_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IIF(c, BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(125, s), p, o, m)
#define BOOST_PP_FOR_125_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IIF(c, BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(126, s), p, o, m)
#define BOOST_PP_FOR_126_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IIF(c, BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(127, s), p, o, m)
#define BOOST_PP_FOR_127_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IIF(c, BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(128, s), p, o, m)
#define BOOST_PP_FOR_128_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IIF(c, BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(129, s), p, o, m)
#define BOOST_PP_FOR_129_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IIF(c, BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(130, s), p, o, m)
#define BOOST_PP_FOR_130_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IIF(c, BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(131, s), p, o, m)
#define BOOST_PP_FOR_131_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IIF(c, BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(132, s), p, o, m)
#define BOOST_PP_FOR_132_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IIF(c, BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(133, s), p, o, m)
#define BOOST_PP_FOR_133_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IIF(c, BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(134, s), p, o, m)
#define BOOST_PP_FOR_134_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IIF(c, BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(135, s), p, o, m)
#define BOOST_PP_FOR_135_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IIF(c, BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(136, s), p, o, m)
#define BOOST_PP_FOR_136_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IIF(c, BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(137, s), p, o, m)
#define BOOST_PP_FOR_137_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IIF(c, BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(138, s), p, o, m)
#define BOOST_PP_FOR_138_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IIF(c, BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(139, s), p, o, m)
#define BOOST_PP_FOR_139_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IIF(c, BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(140, s), p, o, m)
#define BOOST_PP_FOR_140_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IIF(c, BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(141, s), p, o, m)
#define BOOST_PP_FOR_141_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IIF(c, BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(142, s), p, o, m)
#define BOOST_PP_FOR_142_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IIF(c, BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(143, s), p, o, m)
#define BOOST_PP_FOR_143_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IIF(c, BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(144, s), p, o, m)
#define BOOST_PP_FOR_144_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IIF(c, BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(145, s), p, o, m)
#define BOOST_PP_FOR_145_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IIF(c, BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(146, s), p, o, m)
#define BOOST_PP_FOR_146_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IIF(c, BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(147, s), p, o, m)
#define BOOST_PP_FOR_147_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IIF(c, BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(148, s), p, o, m)
#define BOOST_PP_FOR_148_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IIF(c, BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(149, s), p, o, m)
#define BOOST_PP_FOR_149_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IIF(c, BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(150, s), p, o, m)
#define BOOST_PP_FOR_150_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IIF(c, BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(151, s), p, o, m)
#define BOOST_PP_FOR_151_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IIF(c, BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(152, s), p, o, m)
#define BOOST_PP_FOR_152_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IIF(c, BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(153, s), p, o, m)
#define BOOST_PP_FOR_153_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IIF(c, BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(154, s), p, o, m)
#define BOOST_PP_FOR_154_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IIF(c, BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(155, s), p, o, m)
#define BOOST_PP_FOR_155_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IIF(c, BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(156, s), p, o, m)
#define BOOST_PP_FOR_156_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IIF(c, BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(157, s), p, o, m)
#define BOOST_PP_FOR_157_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IIF(c, BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(158, s), p, o, m)
#define BOOST_PP_FOR_158_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IIF(c, BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(159, s), p, o, m)
#define BOOST_PP_FOR_159_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IIF(c, BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(160, s), p, o, m)
#define BOOST_PP_FOR_160_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IIF(c, BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(161, s), p, o, m)
#define BOOST_PP_FOR_161_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IIF(c, BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(162, s), p, o, m)
#define BOOST_PP_FOR_162_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IIF(c, BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(163, s), p, o, m)
#define BOOST_PP_FOR_163_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IIF(c, BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(164, s), p, o, m)
#define BOOST_PP_FOR_164_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IIF(c, BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(165, s), p, o, m)
#define BOOST_PP_FOR_165_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IIF(c, BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(166, s), p, o, m)
#define BOOST_PP_FOR_166_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IIF(c, BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(167, s), p, o, m)
#define BOOST_PP_FOR_167_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IIF(c, BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(168, s), p, o, m)
#define BOOST_PP_FOR_168_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IIF(c, BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(169, s), p, o, m)
#define BOOST_PP_FOR_169_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IIF(c, BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(170, s), p, o, m)
#define BOOST_PP_FOR_170_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IIF(c, BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(171, s), p, o, m)
#define BOOST_PP_FOR_171_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IIF(c, BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(172, s), p, o, m)
#define BOOST_PP_FOR_172_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IIF(c, BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(173, s), p, o, m)
#define BOOST_PP_FOR_173_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IIF(c, BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(174, s), p, o, m)
#define BOOST_PP_FOR_174_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IIF(c, BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(175, s), p, o, m)
#define BOOST_PP_FOR_175_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IIF(c, BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(176, s), p, o, m)
#define BOOST_PP_FOR_176_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IIF(c, BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(177, s), p, o, m)
#define BOOST_PP_FOR_177_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IIF(c, BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(178, s), p, o, m)
#define BOOST_PP_FOR_178_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IIF(c, BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(179, s), p, o, m)
#define BOOST_PP_FOR_179_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IIF(c, BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(180, s), p, o, m)
#define BOOST_PP_FOR_180_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IIF(c, BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(181, s), p, o, m)
#define BOOST_PP_FOR_181_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IIF(c, BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(182, s), p, o, m)
#define BOOST_PP_FOR_182_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IIF(c, BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(183, s), p, o, m)
#define BOOST_PP_FOR_183_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IIF(c, BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(184, s), p, o, m)
#define BOOST_PP_FOR_184_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IIF(c, BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(185, s), p, o, m)
#define BOOST_PP_FOR_185_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IIF(c, BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(186, s), p, o, m)
#define BOOST_PP_FOR_186_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IIF(c, BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(187, s), p, o, m)
#define BOOST_PP_FOR_187_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IIF(c, BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(188, s), p, o, m)
#define BOOST_PP_FOR_188_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IIF(c, BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(189, s), p, o, m)
#define BOOST_PP_FOR_189_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IIF(c, BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(190, s), p, o, m)
#define BOOST_PP_FOR_190_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IIF(c, BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(191, s), p, o, m)
#define BOOST_PP_FOR_191_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IIF(c, BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(192, s), p, o, m)
#define BOOST_PP_FOR_192_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IIF(c, BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(193, s), p, o, m)
#define BOOST_PP_FOR_193_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IIF(c, BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(194, s), p, o, m)
#define BOOST_PP_FOR_194_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IIF(c, BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(195, s), p, o, m)
#define BOOST_PP_FOR_195_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IIF(c, BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(196, s), p, o, m)
#define BOOST_PP_FOR_196_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IIF(c, BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(197, s), p, o, m)
#define BOOST_PP_FOR_197_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IIF(c, BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(198, s), p, o, m)
#define BOOST_PP_FOR_198_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IIF(c, BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(199, s), p, o, m)
#define BOOST_PP_FOR_199_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IIF(c, BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(200, s), p, o, m)
#define BOOST_PP_FOR_200_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IIF(c, BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(201, s), p, o, m)
#define BOOST_PP_FOR_201_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IIF(c, BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(202, s), p, o, m)
#define BOOST_PP_FOR_202_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IIF(c, BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(203, s), p, o, m)
#define BOOST_PP_FOR_203_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IIF(c, BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(204, s), p, o, m)
#define BOOST_PP_FOR_204_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IIF(c, BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(205, s), p, o, m)
#define BOOST_PP_FOR_205_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IIF(c, BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(206, s), p, o, m)
#define BOOST_PP_FOR_206_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IIF(c, BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(207, s), p, o, m)
#define BOOST_PP_FOR_207_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IIF(c, BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(208, s), p, o, m)
#define BOOST_PP_FOR_208_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IIF(c, BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(209, s), p, o, m)
#define BOOST_PP_FOR_209_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IIF(c, BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(210, s), p, o, m)
#define BOOST_PP_FOR_210_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IIF(c, BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(211, s), p, o, m)
#define BOOST_PP_FOR_211_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IIF(c, BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(212, s), p, o, m)
#define BOOST_PP_FOR_212_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IIF(c, BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(213, s), p, o, m)
#define BOOST_PP_FOR_213_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IIF(c, BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(214, s), p, o, m)
#define BOOST_PP_FOR_214_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IIF(c, BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(215, s), p, o, m)
#define BOOST_PP_FOR_215_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IIF(c, BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(216, s), p, o, m)
#define BOOST_PP_FOR_216_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IIF(c, BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(217, s), p, o, m)
#define BOOST_PP_FOR_217_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IIF(c, BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(218, s), p, o, m)
#define BOOST_PP_FOR_218_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IIF(c, BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(219, s), p, o, m)
#define BOOST_PP_FOR_219_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IIF(c, BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(220, s), p, o, m)
#define BOOST_PP_FOR_220_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IIF(c, BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(221, s), p, o, m)
#define BOOST_PP_FOR_221_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IIF(c, BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(222, s), p, o, m)
#define BOOST_PP_FOR_222_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IIF(c, BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(223, s), p, o, m)
#define BOOST_PP_FOR_223_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IIF(c, BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(224, s), p, o, m)
#define BOOST_PP_FOR_224_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IIF(c, BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(225, s), p, o, m)
#define BOOST_PP_FOR_225_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IIF(c, BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(226, s), p, o, m)
#define BOOST_PP_FOR_226_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IIF(c, BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(227, s), p, o, m)
#define BOOST_PP_FOR_227_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IIF(c, BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(228, s), p, o, m)
#define BOOST_PP_FOR_228_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IIF(c, BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(229, s), p, o, m)
#define BOOST_PP_FOR_229_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IIF(c, BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(230, s), p, o, m)
#define BOOST_PP_FOR_230_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IIF(c, BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(231, s), p, o, m)
#define BOOST_PP_FOR_231_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IIF(c, BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(232, s), p, o, m)
#define BOOST_PP_FOR_232_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IIF(c, BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(233, s), p, o, m)
#define BOOST_PP_FOR_233_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IIF(c, BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(234, s), p, o, m)
#define BOOST_PP_FOR_234_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IIF(c, BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(235, s), p, o, m)
#define BOOST_PP_FOR_235_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IIF(c, BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(236, s), p, o, m)
#define BOOST_PP_FOR_236_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IIF(c, BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(237, s), p, o, m)
#define BOOST_PP_FOR_237_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IIF(c, BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(238, s), p, o, m)
#define BOOST_PP_FOR_238_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IIF(c, BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(239, s), p, o, m)
#define BOOST_PP_FOR_239_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IIF(c, BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(240, s), p, o, m)
#define BOOST_PP_FOR_240_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IIF(c, BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(241, s), p, o, m)
#define BOOST_PP_FOR_241_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IIF(c, BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(242, s), p, o, m)
#define BOOST_PP_FOR_242_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IIF(c, BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(243, s), p, o, m)
#define BOOST_PP_FOR_243_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IIF(c, BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(244, s), p, o, m)
#define BOOST_PP_FOR_244_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IIF(c, BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(245, s), p, o, m)
#define BOOST_PP_FOR_245_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IIF(c, BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(246, s), p, o, m)
#define BOOST_PP_FOR_246_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IIF(c, BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(247, s), p, o, m)
#define BOOST_PP_FOR_247_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IIF(c, BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(248, s), p, o, m)
#define BOOST_PP_FOR_248_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IIF(c, BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(249, s), p, o, m)
#define BOOST_PP_FOR_249_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IIF(c, BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(250, s), p, o, m)
#define BOOST_PP_FOR_250_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IIF(c, BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(251, s), p, o, m)
#define BOOST_PP_FOR_251_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IIF(c, BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(252, s), p, o, m)
#define BOOST_PP_FOR_252_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IIF(c, BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(253, s), p, o, m)
#define BOOST_PP_FOR_253_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IIF(c, BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(254, s), p, o, m)
#define BOOST_PP_FOR_254_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IIF(c, BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(255, s), p, o, m)
#define BOOST_PP_FOR_255_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IIF(c, BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(256, s), p, o, m)
#define BOOST_PP_FOR_256_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IIF(c, BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(257, s), p, o, m)
# 43 "/usr/include/boost-1_41/boost/preprocessor/repetition/for.hpp" 2


#define BOOST_PP_FOR_257(s,p,o,m) BOOST_PP_ERROR(0x0002)

#define BOOST_PP_FOR_CHECK_BOOST_PP_NIL 1

#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_1(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_2(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_3(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_4(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_5(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_6(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_7(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_8(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_9(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_10(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_11(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_12(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_13(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_14(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_15(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_16(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_17(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_18(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_19(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_20(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_21(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_22(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_23(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_24(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_25(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_26(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_27(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_28(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_29(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_30(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_31(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_32(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_33(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_34(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_35(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_36(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_37(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_38(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_39(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_40(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_41(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_42(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_43(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_44(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_45(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_46(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_47(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_48(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_49(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_50(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_51(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_52(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_53(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_54(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_55(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_56(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_57(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_58(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_59(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_60(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_61(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_62(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_63(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_64(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_65(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_66(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_67(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_68(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_69(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_70(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_71(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_72(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_73(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_74(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_75(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_76(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_77(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_78(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_79(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_80(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_81(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_82(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_83(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_84(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_85(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_86(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_87(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_88(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_89(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_90(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_91(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_92(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_93(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_94(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_95(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_96(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_97(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_98(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_99(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_100(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_101(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_102(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_103(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_104(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_105(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_106(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_107(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_108(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_109(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_110(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_111(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_112(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_113(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_114(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_115(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_116(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_117(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_118(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_119(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_120(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_121(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_122(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_123(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_124(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_125(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_126(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_127(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_128(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_129(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_130(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_131(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_132(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_133(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_134(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_135(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_136(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_137(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_138(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_139(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_140(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_141(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_142(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_143(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_144(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_145(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_146(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_147(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_148(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_149(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_150(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_151(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_152(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_153(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_154(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_155(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_156(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_157(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_158(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_159(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_160(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_161(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_162(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_163(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_164(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_165(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_166(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_167(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_168(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_169(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_170(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_171(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_172(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_173(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_174(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_175(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_176(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_177(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_178(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_179(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_180(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_181(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_182(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_183(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_184(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_185(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_186(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_187(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_188(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_189(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_190(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_191(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_192(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_193(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_194(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_195(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_196(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_197(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_198(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_199(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_200(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_201(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_202(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_203(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_204(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_205(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_206(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_207(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_208(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_209(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_210(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_211(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_212(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_213(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_214(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_215(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_216(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_217(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_218(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_219(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_220(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_221(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_222(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_223(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_224(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_225(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_226(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_227(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_228(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_229(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_230(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_231(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_232(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_233(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_234(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_235(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_236(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_237(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_238(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_239(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_240(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_241(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_242(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_243(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_244(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_245(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_246(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_247(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_248(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_249(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_250(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_251(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_252(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_253(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_254(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_255(s,p,o,m) 0
#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_256(s,p,o,m) 0
# 21 "/usr/include/boost-1_41/boost/preprocessor/list/for_each_i.hpp" 2

# 1 "/usr/include/boost-1_41/boost/preprocessor/tuple/rem.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/tuple/rem.hpp"
#define BOOST_PREPROCESSOR_TUPLE_REM_HPP 






#define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_I(size)





#define BOOST_PP_TUPLE_REM_I(size) BOOST_PP_TUPLE_REM_ ## size

#define BOOST_PP_TUPLE_REM_0() 
#define BOOST_PP_TUPLE_REM_1(a) a
#define BOOST_PP_TUPLE_REM_2(a,b) a, b
#define BOOST_PP_TUPLE_REM_3(a,b,c) a, b, c
#define BOOST_PP_TUPLE_REM_4(a,b,c,d) a, b, c, d
#define BOOST_PP_TUPLE_REM_5(a,b,c,d,e) a, b, c, d, e
#define BOOST_PP_TUPLE_REM_6(a,b,c,d,e,f) a, b, c, d, e, f
#define BOOST_PP_TUPLE_REM_7(a,b,c,d,e,f,g) a, b, c, d, e, f, g
#define BOOST_PP_TUPLE_REM_8(a,b,c,d,e,f,g,h) a, b, c, d, e, f, g, h
#define BOOST_PP_TUPLE_REM_9(a,b,c,d,e,f,g,h,i) a, b, c, d, e, f, g, h, i
#define BOOST_PP_TUPLE_REM_10(a,b,c,d,e,f,g,h,i,j) a, b, c, d, e, f, g, h, i, j
#define BOOST_PP_TUPLE_REM_11(a,b,c,d,e,f,g,h,i,j,k) a, b, c, d, e, f, g, h, i, j, k
#define BOOST_PP_TUPLE_REM_12(a,b,c,d,e,f,g,h,i,j,k,l) a, b, c, d, e, f, g, h, i, j, k, l
#define BOOST_PP_TUPLE_REM_13(a,b,c,d,e,f,g,h,i,j,k,l,m) a, b, c, d, e, f, g, h, i, j, k, l, m
#define BOOST_PP_TUPLE_REM_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) a, b, c, d, e, f, g, h, i, j, k, l, m, n
#define BOOST_PP_TUPLE_REM_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o
#define BOOST_PP_TUPLE_REM_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p
#define BOOST_PP_TUPLE_REM_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q
#define BOOST_PP_TUPLE_REM_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r
#define BOOST_PP_TUPLE_REM_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s
#define BOOST_PP_TUPLE_REM_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t
#define BOOST_PP_TUPLE_REM_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u
#define BOOST_PP_TUPLE_REM_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v
#define BOOST_PP_TUPLE_REM_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w
#define BOOST_PP_TUPLE_REM_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x
#define BOOST_PP_TUPLE_REM_25(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y




#define BOOST_PP_TUPLE_REM_CTOR(size,tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple)






#define BOOST_PP_TUPLE_REM_CTOR_I(ext,tuple) ext tuple
# 23 "/usr/include/boost-1_41/boost/preprocessor/list/for_each_i.hpp" 2




#define BOOST_PP_LIST_FOR_EACH_I(macro,data,list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M)






#define BOOST_PP_LIST_FOR_EACH_I_P(r,x) BOOST_PP_LIST_FOR_EACH_I_P_D x
#define BOOST_PP_LIST_FOR_EACH_I_P_D(m,d,l,i) BOOST_PP_LIST_IS_CONS(l)





#define BOOST_PP_LIST_FOR_EACH_I_O(r,x) BOOST_PP_LIST_FOR_EACH_I_O_D x
#define BOOST_PP_LIST_FOR_EACH_I_O_D(m,d,l,i) (m, d, BOOST_PP_LIST_REST(l), BOOST_PP_INC(i))





#define BOOST_PP_LIST_FOR_EACH_I_M(r,x) BOOST_PP_LIST_FOR_EACH_I_M_D(r, BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x))





#define BOOST_PP_LIST_FOR_EACH_I_M_D(r,m,d,l,i) m(r, d, i, BOOST_PP_LIST_FIRST(l))




#define BOOST_PP_LIST_FOR_EACH_I_R(r,macro,data,list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M)
# 13 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/tuple/to_list.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/tuple/to_list.hpp"
#define BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP 






#define BOOST_PP_TUPLE_TO_LIST(size,tuple) BOOST_PP_TUPLE_TO_LIST_I(size, tuple)

#define BOOST_PP_TUPLE_TO_LIST_I(s,t) BOOST_PP_TUPLE_TO_LIST_ ## s t
# 35 "/usr/include/boost-1_41/boost/preprocessor/tuple/to_list.hpp"
#define BOOST_PP_TUPLE_TO_LIST_0() BOOST_PP_NIL
#define BOOST_PP_TUPLE_TO_LIST_1(a) (a, BOOST_PP_NIL)
#define BOOST_PP_TUPLE_TO_LIST_2(a,b) (a, (b, BOOST_PP_NIL))
#define BOOST_PP_TUPLE_TO_LIST_3(a,b,c) (a, (b, (c, BOOST_PP_NIL)))
#define BOOST_PP_TUPLE_TO_LIST_4(a,b,c,d) (a, (b, (c, (d, BOOST_PP_NIL))))
#define BOOST_PP_TUPLE_TO_LIST_5(a,b,c,d,e) (a, (b, (c, (d, (e, BOOST_PP_NIL)))))
#define BOOST_PP_TUPLE_TO_LIST_6(a,b,c,d,e,f) (a, (b, (c, (d, (e, (f, BOOST_PP_NIL))))))
#define BOOST_PP_TUPLE_TO_LIST_7(a,b,c,d,e,f,g) (a, (b, (c, (d, (e, (f, (g, BOOST_PP_NIL)))))))
#define BOOST_PP_TUPLE_TO_LIST_8(a,b,c,d,e,f,g,h) (a, (b, (c, (d, (e, (f, (g, (h, BOOST_PP_NIL))))))))
#define BOOST_PP_TUPLE_TO_LIST_9(a,b,c,d,e,f,g,h,i) (a, (b, (c, (d, (e, (f, (g, (h, (i, BOOST_PP_NIL)))))))))
#define BOOST_PP_TUPLE_TO_LIST_10(a,b,c,d,e,f,g,h,i,j) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, BOOST_PP_NIL))))))))))
#define BOOST_PP_TUPLE_TO_LIST_11(a,b,c,d,e,f,g,h,i,j,k) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, BOOST_PP_NIL)))))))))))
#define BOOST_PP_TUPLE_TO_LIST_12(a,b,c,d,e,f,g,h,i,j,k,l) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, BOOST_PP_NIL))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_13(a,b,c,d,e,f,g,h,i,j,k,l,m) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, BOOST_PP_NIL)))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, BOOST_PP_NIL))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, BOOST_PP_NIL)))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, BOOST_PP_NIL))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, BOOST_PP_NIL)))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, BOOST_PP_NIL))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, BOOST_PP_NIL)))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, BOOST_PP_NIL))))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, BOOST_PP_NIL)))))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, BOOST_PP_NIL))))))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, BOOST_PP_NIL)))))))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, BOOST_PP_NIL))))))))))))))))))))))))
#define BOOST_PP_TUPLE_TO_LIST_25(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, (y, BOOST_PP_NIL)))))))))))))))))))))))))
# 14 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2

# 1 "/usr/include/boost-1_41/boost/preprocessor/list/transform.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/transform.hpp"
#define BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP 
# 25 "/usr/include/boost-1_41/boost/preprocessor/list/transform.hpp"
#define BOOST_PP_LIST_TRANSFORM(op,data,list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))






#define BOOST_PP_LIST_TRANSFORM_O(d,odr,elem) BOOST_PP_LIST_TRANSFORM_O_D(d, BOOST_PP_TUPLE_ELEM(3, 0, odr), BOOST_PP_TUPLE_ELEM(3, 1, odr), BOOST_PP_TUPLE_ELEM(3, 2, odr), elem)





#define BOOST_PP_LIST_TRANSFORM_O_D(d,op,data,res,elem) (op, data, (op(d, data, elem), res))




#define BOOST_PP_LIST_TRANSFORM_D(d,op,data,list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))
# 16 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/list/append.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/list/append.hpp"
#define BOOST_PREPROCESSOR_LIST_APPEND_HPP 







#define BOOST_PP_LIST_APPEND(a,b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a)





#define BOOST_PP_LIST_APPEND_O(d,s,x) (x, s)




#define BOOST_PP_LIST_APPEND_D(d,a,b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a)
# 17 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 24 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 26 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2






namespace boost {



namespace detail {

class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();


#define BOOST_TT_ALIGNMENT_BASE_TYPES BOOST_PP_TUPLE_TO_LIST( 12, ( char, short, int, long, ::boost::long_long_type, float, double, long double , void*, function_ptr, member_ptr, member_function_ptr))
# 55 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
#define BOOST_TT_HAS_ONE_T(D,Data,T) boost::detail::has_one_T< T >

#define BOOST_TT_ALIGNMENT_STRUCT_TYPES BOOST_PP_LIST_TRANSFORM(BOOST_TT_HAS_ONE_T, X, BOOST_TT_ALIGNMENT_BASE_TYPES)




#define BOOST_TT_ALIGNMENT_TYPES BOOST_PP_LIST_APPEND(BOOST_TT_ALIGNMENT_BASE_TYPES, BOOST_TT_ALIGNMENT_STRUCT_TYPES)
# 101 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
template <bool found, std::size_t target, class TestType>
struct lower_alignment_helper
{
    typedef char type;
    enum { value = true };
};

template <std::size_t target, class TestType>
struct lower_alignment_helper<false,target,TestType>
{
    enum { value = (alignment_of<TestType>::value == target) };
    typedef typename mpl::if_c<value, TestType, char>::type type;
};


#define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) typename lower_alignment_helper< BOOST_PP_CAT(found,I),target,T >::type BOOST_PP_CAT(t,I); enum { BOOST_PP_CAT(found,BOOST_PP_INC(I)) = lower_alignment_helper<BOOST_PP_CAT(found,I),target,T >::value };
# 125 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
#define BOOST_TT_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I);

template <typename T>
struct has_one_T
{
  T data;
};

template <std::size_t target>
union lower_alignment
{
    enum { found0 = false };

    typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< found7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };




};

union max_align
{
    char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;




};

#undef BOOST_TT_ALIGNMENT_BASE_TYPES
#undef BOOST_TT_HAS_ONE_T
#undef BOOST_TT_ALIGNMENT_STRUCT_TYPES
#undef BOOST_TT_ALIGNMENT_TYPES
#undef BOOST_TT_CHOOSE_MIN_ALIGNMENT
#undef BOOST_TT_CHOOSE_T

template<std::size_t TAlign, std::size_t Align>
struct is_aligned
{
    static const bool value = (TAlign >= Align) & (TAlign % Align == 0);


};
# 180 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
}


template<std::size_t Align>
struct is_pod< ::boost::detail::lower_alignment<Align> >
{
        static const std::size_t value = true;
};




namespace detail{

template <std::size_t Align>
class type_with_alignment_imp
{
    typedef ::boost::detail::lower_alignment<Align> t1;
    typedef typename mpl::if_c<
          ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
        , t1
        , ::boost::detail::max_align
        >::type align_t;

    static const std::size_t found = alignment_of<align_t>::value;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found >= Align) == 0 ? false : true) >)> boost_static_assert_typedef_206;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found % Align == 0) == 0 ? false : true) >)> boost_static_assert_typedef_207;

 public:
    typedef align_t type;
};

}

template <std::size_t Align>
class type_with_alignment
  : public ::boost::detail::type_with_alignment_imp<Align>
{
};


namespace align {
struct __attribute__((__aligned__(2))) a2 {};
struct __attribute__((__aligned__(4))) a4 {};
struct __attribute__((__aligned__(8))) a8 {};
struct __attribute__((__aligned__(16))) a16 {};
struct __attribute__((__aligned__(32))) a32 {};
}

template<> class type_with_alignment<1> { public: typedef char type; };
template<> class type_with_alignment<2> { public: typedef align::a2 type; };
template<> class type_with_alignment<4> { public: typedef align::a4 type; };
template<> class type_with_alignment<8> { public: typedef align::a8 type; };
template<> class type_with_alignment<16> { public: typedef align::a16 type; };
template<> class type_with_alignment<32> { public: typedef align::a32 type; };

namespace detail {
template<> struct is_pod_impl< ::boost::align::a2 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a4 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a8 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a16 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a32 > { static const bool value = (true); };
}
# 383 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp"
}





# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 390 "/usr/include/boost-1_41/boost/type_traits/type_with_alignment.hpp" 2
# 71 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/function_traits.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/function_traits.hpp"
#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED 





namespace boost {


namespace detail {

template<typename Function> struct function_traits_helper;

template<typename R>
struct function_traits_helper<R (*)(void)>
{
  static const unsigned arity = 0;
  typedef R result_type;
};

template<typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
  static const unsigned arity = 1;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T1 argument_type;
};

template<typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
  static const unsigned arity = 2;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T1 first_argument_type;
  typedef T2 second_argument_type;
};

template<typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
  static const unsigned arity = 3;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
  static const unsigned arity = 4;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
  static const unsigned arity = 5;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
  static const unsigned arity = 6;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
  static const unsigned arity = 7;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
  static const unsigned arity = 8;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
  static const unsigned arity = 9;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
  static const unsigned arity = 10;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
  typedef T10 arg10_type;
};

}

template<typename Function>
struct function_traits :
   public detail::function_traits_helper<typename boost::add_pointer<Function>::type>
{
};
# 234 "/usr/include/boost-1_41/boost/type_traits/function_traits.hpp"
}
# 72 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/aligned_storage.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/aligned_storage.hpp"
#define BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED 
# 1 "/usr/include/boost-1_41/boost/aligned_storage.hpp" 1
# 14 "/usr/include/boost-1_41/boost/aligned_storage.hpp"
#define BOOST_ALIGNED_STORAGE_HPP 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 17 "/usr/include/boost-1_41/boost/aligned_storage.hpp" 2
# 27 "/usr/include/boost-1_41/boost/aligned_storage.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 28 "/usr/include/boost-1_41/boost/aligned_storage.hpp" 2

namespace boost {

namespace detail { namespace aligned_storage {

static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value;







template <
      std::size_t size_
    , std::size_t alignment_
>
struct aligned_storage_imp
{
    union data_t
    {
        char buf[size_];

        typename mpl::eval_if_c<
              alignment_ == std::size_t(-1)
            , mpl::identity<detail::max_align>
            , type_with_alignment<alignment_>
            >::type align_;
    } data_;
    void* address() const { return const_cast<aligned_storage_imp*>(this); }
};

template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{

    void* address() const { return 0; }
};

}}

template <
      std::size_t size_
    , std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :

   private



   detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{

public:

    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;

    static const std::size_t size = size_;



    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ );
# 104 "/usr/include/boost-1_41/boost/aligned_storage.hpp"
private:

    aligned_storage(const aligned_storage&);
    aligned_storage& operator=(const aligned_storage&);
# 118 "/usr/include/boost-1_41/boost/aligned_storage.hpp"
public:

    aligned_storage()
    {
    }

    ~aligned_storage()
    {
    }

public:

    void* address()
    {
        return static_cast<type*>(this)->address();
    }



    const void* address() const
    {
        return static_cast<const type*>(this)->address();
    }







};
# 168 "/usr/include/boost-1_41/boost/aligned_storage.hpp"
template <std::size_t size_, std::size_t alignment_>
struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
   : ::boost::integral_constant<bool,true>
{
   
};



}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 180 "/usr/include/boost-1_41/boost/aligned_storage.hpp" 2
# 12 "/usr/include/boost-1_41/boost/type_traits/aligned_storage.hpp" 2
# 73 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/floating_point_promotion.hpp" 1






#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/floating_point_promotion.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 22 "/usr/include/boost-1_41/boost/type_traits/floating_point_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {



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

template<>
struct floating_point_promotion<float>
{
    typedef double type;
};

template<>
struct floating_point_promotion<float const>
{
    typedef double const type;
};

template<>
struct floating_point_promotion<float volatile>
{
    typedef double volatile type;
};

template<>
struct floating_point_promotion<float const volatile>
{
    typedef double const volatile type;
};
# 78 "/usr/include/boost-1_41/boost/type_traits/floating_point_promotion.hpp"
} }

template< typename T > struct floating_point_promotion { typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };





}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 89 "/usr/include/boost-1_41/boost/type_traits/floating_point_promotion.hpp" 2
# 74 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp" 1






#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 21 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {


template <class T> struct need_promotion : boost::is_enum<T> {};


template<> struct need_promotion<char > : true_type {};
template<> struct need_promotion<signed char > : true_type {};
template<> struct need_promotion<unsigned char > : true_type {};
template<> struct need_promotion<signed short int > : true_type {};
template<> struct need_promotion<unsigned short int> : true_type {};





#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) template<> struct need_promotion<T> : integral_constant<bool, (sizeof(T) < sizeof(int))> {};
# 63 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp"
template<> struct need_promotion<boost::ulong_long_type> : integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
template<> struct need_promotion<boost::long_long_type> : integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};





#undef BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE




template<> struct need_promotion<wchar_t> : true_type {};





template<> struct need_promotion<bool> : true_type {};




template<int Index, int IsConst, int IsVolatile> struct promote_from_index;

#define BOOST_TT_AUX_PROMOTE_FROM_INDEX(N,T) template<> struct promote_from_index<N,0,0> { typedef T type; }; template<> struct promote_from_index<N,0,1> { typedef T volatile type; }; template<> struct promote_from_index<N,1,0> { typedef T const type; }; template<> struct promote_from_index<N,1,1> { typedef T const volatile type; };






template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
# 107 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp"
template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };





#undef BOOST_TT_AUX_PROMOTE_FROM_INDEX





template<int N>
struct sized_type_for_promotion
{
    typedef char (&type)[N];
};

#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) sized_type_for_promotion<I>::type promoted_index_tester(T);
# 136 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp"
sized_type_for_promotion<1>::type promoted_index_tester(int);
sized_type_for_promotion<2>::type promoted_index_tester(unsigned int);
sized_type_for_promotion<3>::type promoted_index_tester(long);
sized_type_for_promotion<4>::type promoted_index_tester(unsigned long);


sized_type_for_promotion<5>::type promoted_index_tester(boost::long_long_type);
sized_type_for_promotion<6>::type promoted_index_tester(boost::ulong_long_type);





#undef BOOST_TT_AUX_PROMOTED_INDEX_TESTER




template<class T>
struct promoted_index
{
    static T testee;
    static const int value = sizeof(promoted_index_tester(+testee));

};

template<class T>
struct integral_promotion_impl
{
    typedef typename promote_from_index<
        (boost::type_traits::detail::promoted_index<T>::value)
      , (boost::is_const<T>::value)
      , (boost::is_volatile<T>::value)
      >::type type;
};

template<class T>
struct integral_promotion
  : boost::mpl::eval_if<
        need_promotion<typename remove_cv<T>::type>
      , integral_promotion_impl<T>
      , boost::mpl::identity<T>
      >
{
};

} }

template< typename T > struct integral_promotion { typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };





}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 193 "/usr/include/boost-1_41/boost/type_traits/integral_promotion.hpp" 2
# 76 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/promote.hpp" 1






#define FILE_boost_type_traits_promote_hpp_INCLUDED 






# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 15 "/usr/include/boost-1_41/boost/type_traits/promote.hpp" 2

namespace boost {

namespace detail {

template<class T>
struct promote_impl
  : integral_promotion<
        typename floating_point_promotion<T>::type
      >
{
};

}

template< typename T > struct promote { typedef typename boost::detail::promote_impl<T>::type type; };




}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 38 "/usr/include/boost-1_41/boost/type_traits/promote.hpp" 2
# 77 "/usr/include/boost-1_41/boost/type_traits.hpp" 2

# 1 "/usr/include/boost-1_41/boost/type_traits/make_unsigned.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/make_unsigned.hpp"
#define BOOST_TT_MAKE_UNSIGNED_HPP_INCLUDED 
# 29 "/usr/include/boost-1_41/boost/type_traits/make_unsigned.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 30 "/usr/include/boost-1_41/boost/type_traits/make_unsigned.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_unsigned_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_39;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_43;




   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_unsigned<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, signed char>,
            unsigned char,
            typename mpl::if_<
               is_same<t_no_cv, short>,
               unsigned short,
               typename mpl::if_<
                  is_same<t_no_cv, int>,
                  unsigned int,
                  typename mpl::if_<
                     is_same<t_no_cv, long>,
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            unsigned char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               unsigned short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  unsigned int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_unsigned { typedef typename boost::detail::make_unsigned_imp<T>::type type; };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 135 "/usr/include/boost-1_41/boost/type_traits/make_unsigned.hpp" 2
# 79 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/make_signed.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/make_signed.hpp"
#define BOOST_TT_MAKE_SIGNED_HPP_INCLUDED 
# 29 "/usr/include/boost-1_41/boost/type_traits/make_signed.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp" 2


#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 27 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_def.hpp"
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };







#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { typedef result type; };






#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { typedef result; };






#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { typedef result type; };
# 30 "/usr/include/boost-1_41/boost/type_traits/make_signed.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_signed_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_39;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_43;




   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_signed<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, unsigned char>,
            signed char,
            typename mpl::if_<
               is_same<t_no_cv, unsigned short>,
               signed short,
               typename mpl::if_<
                  is_same<t_no_cv, unsigned int>,
                  int,
                  typename mpl::if_<
                     is_same<t_no_cv, unsigned long>,
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            signed char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               signed short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_signed { typedef typename boost::detail::make_signed_imp<T>::type type; };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/type_trait_undef.hpp"
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
# 135 "/usr/include/boost-1_41/boost/type_traits/make_signed.hpp" 2
# 80 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/decay.hpp" 1
# 10 "/usr/include/boost-1_41/boost/type_traits/decay.hpp"
#define BOOST_TT_DECAY_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/type_traits/decay.hpp"
namespace boost
{

    template< class T >
    struct decay
    {
    private:
        typedef typename remove_reference<T>::type Ty;
    public:
        typedef typename mpl::eval_if<
            is_array<Ty>,
            mpl::identity<typename remove_bounds<Ty>::type*>,
            typename mpl::eval_if<
                is_function<Ty>,
                add_pointer<Ty>,
                mpl::identity<Ty>
            >
        >::type type;
    };

}
# 81 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 1 "/usr/include/boost-1_41/boost/type_traits/is_complex.hpp" 1
# 9 "/usr/include/boost-1_41/boost/type_traits/is_complex.hpp"
#define BOOST_TT_IS_COMPLEX_HPP 




# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp" 1
# 30 "/usr/include/boost-1_41/boost/type_traits/detail/template_arity_spec.hpp"
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name) 
# 15 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp" 2
# 59 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) 



#define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>



#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
# 79 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
# 90 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
# 99 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 108 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };






#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
# 147 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_def.hpp"
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };







#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { BOOST_STATIC_CONSTANT(bool, value = (C)); };







#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
# 15 "/usr/include/boost-1_41/boost/type_traits/is_complex.hpp" 2


namespace boost {
namespace detail{

struct is_convertible_from_tester
{
   template <class T>
   is_convertible_from_tester(const std::complex<T>&);
};

}

template< typename T > struct is_complex : ::boost::integral_constant<bool,(::boost::is_convertible<T, detail::is_convertible_from_tester>::value)> { };

}

# 1 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/detail/bool_trait_undef.hpp"
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
# 33 "/usr/include/boost-1_41/boost/type_traits/is_complex.hpp" 2
# 82 "/usr/include/boost-1_41/boost/type_traits.hpp" 2
# 25 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" 2



namespace {
  template<class T> T boost_numeric_ublas_sqrt (const T& t) {
    using namespace std;

    return sqrt (t);
  }
  template<class T> T boost_numeric_ublas_abs (const T& t) {
    using namespace std;

    return abs (t);
  }
}

namespace boost { namespace numeric { namespace ublas {



    template<class X, class Y>
    struct promote_traits {
        typedef type_deduction_detail::base_result_of<X, Y> base_type;
        static typename base_type::x_type x;
        static typename base_type::y_type y;
        static const std::size_t size = sizeof (
                type_deduction_detail::test<
                    typename base_type::x_type
                  , typename base_type::y_type
                >(x + y)
            );

        static const std::size_t index = (size / sizeof (char)) - 1;
        typedef typename mpl::at_c<
            typename base_type::types, index>::type id;
        typedef typename id::type promote_type;
    };



    template<class T>
    struct type_traits;


    template<class T>
    struct scalar_traits {
        typedef scalar_traits<T> self_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;

        typedef T real_type;
        typedef real_type precision_type;

        static const unsigned plus_complexity = 1;
        static const unsigned multiplies_complexity = 1;

        static
       
        real_type real (const_reference t) {
                return t;
        }
        static
       
        real_type imag (const_reference ) {
                return 0;
        }
        static
       
        value_type conj (const_reference t) {
                return t;
        }

        static
       
        real_type type_abs (const_reference t) {
            return boost_numeric_ublas_abs (t);
        }
        static
       
        value_type type_sqrt (const_reference t) {

            return value_type (boost_numeric_ublas_sqrt (t));
        }

        static
       
        real_type norm_1 (const_reference t) {
            return self_type::type_abs (t);
        }
        static
       
        real_type norm_2 (const_reference t) {
            return self_type::type_abs (t);
        }
        static
       
        real_type norm_inf (const_reference t) {
            return self_type::type_abs (t);
        }

        static
       
        bool equals (const_reference t1, const_reference t2) {
            return self_type::norm_inf (t1 - t2) < (type_traits<real_type>::type_sqrt (std::numeric_limits<real_type>::epsilon ())) *
                   (std::max) ((std::max) (self_type::norm_inf (t1),
                                       self_type::norm_inf (t2)),
                             (type_traits<real_type>::type_sqrt ( (std::numeric_limits<real_type>::min) ())));
        }
    };


    template<class T>
    struct type_traits : scalar_traits <T> {
        typedef type_traits<T> self_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;

        typedef T real_type;
        typedef real_type precision_type;
        static const unsigned multiplies_complexity = 1;

    };


    template<>
    struct type_traits<float> : scalar_traits<float> {
        typedef type_traits<float> self_type;
        typedef float value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef value_type real_type;
        typedef double precision_type;
    };
    template<>
    struct type_traits<double> : scalar_traits<double> {
        typedef type_traits<double> self_type;
        typedef double value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef value_type real_type;
        typedef long double precision_type;
    };
    template<>
    struct type_traits<long double> : scalar_traits<long double> {
        typedef type_traits<long double> self_type;
        typedef long double value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef value_type real_type;
        typedef value_type precision_type;
    };


    template<class T>
    struct complex_traits {
        typedef complex_traits<T> self_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;

        typedef typename T::value_type real_type;
        typedef real_type precision_type;

        static const unsigned plus_complexity = 2;
        static const unsigned multiplies_complexity = 6;

        static
       
        real_type real (const_reference t) {
                return std::real (t);
        }
        static
       
        real_type imag (const_reference t) {
                return std::imag (t);
        }
        static
       
        value_type conj (const_reference t) {
                return std::conj (t);
        }

        static
       
        real_type type_abs (const_reference t) {
                return abs (t);
        }
        static
       
        value_type type_sqrt (const_reference t) {
                return sqrt (t);
        }

        static
       
        real_type norm_1 (const_reference t) {
            return type_traits<real_type>::type_abs (self_type::real (t)) +
                   type_traits<real_type>::type_abs (self_type::imag (t));
        }
        static
       
        real_type norm_2 (const_reference t) {
            return self_type::type_abs (t);
        }
        static
       
        real_type norm_inf (const_reference t) {
            return (std::max) (type_traits<real_type>::type_abs (self_type::real (t)),
                             type_traits<real_type>::type_abs (self_type::imag (t)));
        }

        static
       
        bool equals (const_reference t1, const_reference t2) {
            return self_type::norm_inf (t1 - t2) < (type_traits<real_type>::type_sqrt (std::numeric_limits<real_type>::epsilon ())) *
                   (std::max) ((std::max) (self_type::norm_inf (t1),
                                       self_type::norm_inf (t2)),
                             (type_traits<real_type>::type_sqrt ( (std::numeric_limits<real_type>::min) ())));
        }
    };


    template<>
    struct type_traits<std::complex<float> > : complex_traits<std::complex<float> >{
        typedef type_traits<std::complex<float> > self_type;
        typedef std::complex<float> value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef float real_type;
        typedef std::complex<double> precision_type;

    };
    template<>
    struct type_traits<std::complex<double> > : complex_traits<std::complex<double> >{
        typedef type_traits<std::complex<double> > self_type;
        typedef std::complex<double> value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef double real_type;
        typedef std::complex<long double> precision_type;
    };
    template<>
    struct type_traits<std::complex<long double> > : complex_traits<std::complex<long double> > {
        typedef type_traits<std::complex<long double> > self_type;
        typedef std::complex<long double> value_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef long double real_type;
        typedef value_type precision_type;
    };
# 313 "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp"
    struct unknown_storage_tag {};
    struct sparse_proxy_tag: public unknown_storage_tag {};
    struct sparse_tag: public sparse_proxy_tag {};
    struct packed_proxy_tag: public sparse_proxy_tag {};
    struct packed_tag: public packed_proxy_tag {};
    struct dense_proxy_tag: public packed_proxy_tag {};
    struct dense_tag: public dense_proxy_tag {};

    template<class S1, class S2>
    struct storage_restrict_traits {
        typedef S1 storage_category;
    };

    template<>
    struct storage_restrict_traits<sparse_tag, dense_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<sparse_tag, packed_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<sparse_tag, sparse_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct storage_restrict_traits<packed_tag, dense_proxy_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<packed_tag, packed_proxy_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<packed_tag, sparse_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct storage_restrict_traits<packed_proxy_tag, sparse_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct storage_restrict_traits<dense_tag, dense_proxy_tag> {
        typedef dense_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<dense_tag, packed_proxy_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<dense_tag, sparse_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct storage_restrict_traits<dense_proxy_tag, packed_proxy_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<>
    struct storage_restrict_traits<dense_proxy_tag, sparse_proxy_tag> {
        typedef sparse_proxy_tag storage_category;
    };




    struct sparse_bidirectional_iterator_tag : public std::bidirectional_iterator_tag {};
    struct packed_random_access_iterator_tag : public std::random_access_iterator_tag {};
    struct dense_random_access_iterator_tag : public packed_random_access_iterator_tag {};


    template<class IC>
    struct iterator_base_traits {};

    template<>
    struct iterator_base_traits<std::forward_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef forward_iterator_base<std::forward_iterator_tag, I, T> type;
        };
    };

    template<>
    struct iterator_base_traits<std::bidirectional_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef bidirectional_iterator_base<std::bidirectional_iterator_tag, I, T> type;
        };
    };
    template<>
    struct iterator_base_traits<sparse_bidirectional_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef bidirectional_iterator_base<sparse_bidirectional_iterator_tag, I, T> type;
        };
    };

    template<>
    struct iterator_base_traits<std::random_access_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef random_access_iterator_base<std::random_access_iterator_tag, I, T> type;
        };
    };
    template<>
    struct iterator_base_traits<packed_random_access_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef random_access_iterator_base<packed_random_access_iterator_tag, I, T> type;
        };
    };
    template<>
    struct iterator_base_traits<dense_random_access_iterator_tag> {
        template<class I, class T>
        struct iterator_base {
            typedef random_access_iterator_base<dense_random_access_iterator_tag, I, T> type;
        };
    };

    template<class I1, class I2>
    struct iterator_restrict_traits {
        typedef I1 iterator_category;
    };

    template<>
    struct iterator_restrict_traits<packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_bidirectional_iterator_tag iterator_category;
    };
    template<>
    struct iterator_restrict_traits<sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag> {
        typedef sparse_bidirectional_iterator_tag iterator_category;
    };

    template<>
    struct iterator_restrict_traits<dense_random_access_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_bidirectional_iterator_tag iterator_category;
    };
    template<>
    struct iterator_restrict_traits<sparse_bidirectional_iterator_tag, dense_random_access_iterator_tag> {
        typedef sparse_bidirectional_iterator_tag iterator_category;
    };

    template<>
    struct iterator_restrict_traits<dense_random_access_iterator_tag, packed_random_access_iterator_tag> {
        typedef packed_random_access_iterator_tag iterator_category;
    };
    template<>
    struct iterator_restrict_traits<packed_random_access_iterator_tag, dense_random_access_iterator_tag> {
        typedef packed_random_access_iterator_tag iterator_category;
    };

    template<class I>
   
    void increment (I &it, const I &it_end, typename I::difference_type compare, packed_random_access_iterator_tag) {
        it += (std::min) (compare, it_end - it);
    }
    template<class I>
   
    void increment (I &it, const I & , typename I::difference_type , sparse_bidirectional_iterator_tag) {
        ++ it;
    }
    template<class I>
   
    void increment (I &it, const I &it_end, typename I::difference_type compare) {
        increment (it, it_end, compare, typename I::iterator_category ());
    }

    template<class I>
   
    void increment (I &it, const I &it_end) {

        I cit (it);
        while (cit != it_end) {
            if (! (*cit == typename I::value_type ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/traits.hpp" << " at line " << 489 << ":" << std::endl; std::cerr << "*cit == typename I::value_type ()" << std::endl; internal_logic ().raise (); };
            ++ cit;
        }

        it = it_end;
    }

    namespace detail {



        template<typename T>
        struct has_trivial_constructor : public boost::has_trivial_constructor<T> {};

        template<typename T>
        struct has_trivial_destructor : public boost::has_trivial_destructor<T> {};

        template<typename FLT>
        struct has_trivial_constructor<std::complex<FLT> > : public boost::true_type {};

        template<typename FLT>
        struct has_trivial_destructor<std::complex<FLT> > : public boost::true_type {};

    }





    template < class E >
    struct container_view_traits {

        typedef typename E::size_type size_type;

        typedef typename E::difference_type difference_type;


        typedef typename E::storage_category storage_category;


        typedef typename E::value_type value_type;

        typedef typename E::const_reference const_reference;


        typedef typename E::const_closure_type const_closure_type;
    };




    template < class E >
    struct mutable_container_traits {

        typedef typename E::reference reference;


        typedef typename E::closure_type closure_type;
    };




    template < class E >
    struct container_traits
 : container_view_traits<E>, mutable_container_traits<E> {

    };





    template < class MATRIX >
    struct matrix_view_traits : container_view_traits <MATRIX> {


        typedef typename MATRIX::orientation_category orientation_category;


        typedef typename MATRIX::const_iterator1 const_iterator1;


        typedef typename MATRIX::const_iterator2 const_iterator2;
    };




    template < class MATRIX >
    struct mutable_matrix_traits
 : mutable_container_traits <MATRIX> {


        typedef typename MATRIX::iterator1 iterator1;


        typedef typename MATRIX::iterator2 iterator2;
    };





    template < class MATRIX >
    struct matrix_traits
 : matrix_view_traits <MATRIX>, mutable_matrix_traits <MATRIX> {
    };




    template < class VECTOR >
    struct vector_view_traits : container_view_traits <VECTOR> {


        typedef typename VECTOR::const_iterator const_iterator;


 static
 const_iterator begin(const VECTOR & v) {
     return v.begin();
 }

 static
 const_iterator end(const VECTOR & v) {
     return v.end();
 }

    };




    template < class VECTOR >
    struct mutable_vector_traits : mutable_container_traits <VECTOR> {

        typedef typename VECTOR::iterator iterator;


 static
 iterator begin(VECTOR & v) {
     return v.begin();
 }


 static
 iterator end(VECTOR & v) {
     return v.end();
 }
    };




    template < class VECTOR >
    struct vector_traits
 : vector_view_traits <VECTOR>, mutable_vector_traits <VECTOR> {
    };




}}}
# 27 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" 2



namespace boost { namespace numeric { namespace ublas {



    template<class E>
    class storage_array:
        private nonassignable {
    };



    template<class T, class ALLOC>
    class unbounded_array:
        public storage_array<unbounded_array<T, ALLOC> > {

        typedef unbounded_array<T, ALLOC> self_type;
    public:
        typedef ALLOC allocator_type;
        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const T *const_pointer;
        typedef T *pointer;
        typedef const_pointer const_iterator;
        typedef pointer iterator;


        explicit
        unbounded_array (const ALLOC &a = ALLOC()):
            alloc_ (a), size_ (0) {
            data_ = 0;
        }
        explicit
        unbounded_array (size_type size, const ALLOC &a = ALLOC()):
            alloc_(a), size_ (size) {
          if (size_) {
              data_ = alloc_.allocate (size_);
              if (! detail::has_trivial_constructor<T>::value) {
                  for (pointer d = data_; d != data_ + size_; ++d)
                      alloc_.construct(d, value_type());
              }
          }
          else
              data_ = 0;
        }

       
        unbounded_array (size_type size, const value_type &init, const ALLOC &a = ALLOC()):
            alloc_ (a), size_ (size) {
            if (size_) {
                data_ = alloc_.allocate (size_);
                std::uninitialized_fill (begin(), end(), init);
            }
            else
                data_ = 0;
        }
       
        unbounded_array (const unbounded_array &c):
            storage_array<unbounded_array<T, ALLOC> >(),
            alloc_ (c.alloc_), size_ (c.size_) {
            if (size_) {
                data_ = alloc_.allocate (size_);
                std::uninitialized_copy (c.begin(), c.end(), begin());
            }
            else
                data_ = 0;
        }
       
        ~unbounded_array () {
            if (size_) {
                if (! detail::has_trivial_destructor<T>::value) {

                    const iterator i_end = end();
                    for (iterator i = begin (); i != i_end; ++i) {
                        iterator_destroy (i);
                    }
                }
                alloc_.deallocate (data_, size_);
            }
        }


    private:
       
        void resize_internal (const size_type size, const value_type init, const bool preserve) {
            if (size != size_) {
                pointer p_data = data_;
                if (size) {
                    data_ = alloc_.allocate (size);
                    if (preserve) {
                        pointer si = p_data;
                        pointer di = data_;
                        if (size < size_) {
                            for (; di != data_ + size; ++di) {
                                alloc_.construct (di, *si);
                                ++si;
                            }
                        }
                        else {
                            for (pointer si = p_data; si != p_data + size_; ++si) {
                                alloc_.construct (di, *si);
                                ++di;
                            }
                            for (; di != data_ + size; ++di) {
                                alloc_.construct (di, init);
                            }
                        }
                    }
                    else {
                        if (! detail::has_trivial_constructor<T>::value) {
                            for (pointer di = data_; di != data_ + size; ++di)
                                alloc_.construct (di, value_type());
                        }
                    }
                }

                if (size_) {
                    if (! detail::has_trivial_destructor<T>::value) {
                        for (pointer si = p_data; si != p_data + size_; ++si)
                            alloc_.destroy (si);
                    }
                    alloc_.deallocate (p_data, size_);
                }

                if (!size)
                    data_ = 0;
                size_ = size;
            }
        }
    public:
       
        void resize (size_type size) {
            resize_internal (size, value_type (), false);
        }
       
        void resize (size_type size, value_type init) {
            resize_internal (size, init, true);
        }


       
        size_type max_size () const {
            return ALLOC ().max_size();
        }

       
        bool empty () const {
            return size_ == 0;
        }

       
        size_type size () const {
            return size_;
        }


       
        const_reference operator [] (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 190 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }
       
        reference operator [] (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 195 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }


       
        unbounded_array &operator = (const unbounded_array &a) {
            if (this != &a) {
                resize (a.size_);
                std::copy (a.data_, a.data_ + a.size_, data_);
            }
            return *this;
        }
       
        unbounded_array &assign_temporary (unbounded_array &a) {
            swap (a);
            return *this;
        }


       
        void swap (unbounded_array &a) {
            if (this != &a) {
                std::swap (size_, a.size_);
                std::swap (data_, a.data_);
            }
        }
       
        friend void swap (unbounded_array &a1, unbounded_array &a2) {
            a1.swap (a2);
        }

       
        const_iterator begin () const {
            return data_;
        }
       
        const_iterator end () const {
            return data_ + size_;
        }

       
        iterator begin () {
            return data_;
        }
       
        iterator end () {
            return data_ + size_;
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
        typedef std::reverse_iterator<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        allocator_type get_allocator () {
            return alloc_;
        }

    private:
        friend class boost::serialization::access;


        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            serialization::collection_size_type s(size_);
            ar & serialization::make_nvp("size",s);
            if ( Archive::is_loading::value ) {
                resize(s);
            }
            ar & serialization::make_array(data_, s);
        }

    private:

       
        static void iterator_destroy (iterator &i) {
            (&(*i)) -> ~value_type ();
        }
        ALLOC alloc_;
        size_type size_;
        pointer data_;
    };


    template<class T, std::size_t N, class ALLOC>
    class bounded_array:
        public storage_array<bounded_array<T, N, ALLOC> > {

        typedef bounded_array<T, N, ALLOC> self_type;
    public:

        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const T *const_pointer;
        typedef T *pointer;
        typedef const_pointer const_iterator;
        typedef pointer iterator;


       
        bounded_array ():
            size_ (0) {
        }
        explicit
        bounded_array (size_type size):
            size_ (size) {
            if (! (size_ <= N)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 323 << ":" << std::endl; std::cerr << "size_ <= N" << std::endl; bad_size ().raise (); };

        }
       
        bounded_array (size_type size, const value_type &init):
            size_ (size) {
            if (! (size_ <= N)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 329 << ":" << std::endl; std::cerr << "size_ <= N" << std::endl; bad_size ().raise (); };

            std::fill (begin(), end(), init) ;
        }
       
        bounded_array (const bounded_array &c):
            size_ (c.size_) {

            std::copy (c.begin(), c.end(), begin());
        }


       
        void resize (size_type size) {
            if (! (size <= N)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 343 << ":" << std::endl; std::cerr << "size <= N" << std::endl; bad_size ().raise (); };
            size_ = size;
        }
       
        void resize (size_type size, value_type init) {
            if (! (size <= N)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 348 << ":" << std::endl; std::cerr << "size <= N" << std::endl; bad_size ().raise (); };
            if (size > size_)
                std::fill (data_ + size_, data_ + size, init);
            size_ = size;
        }


       
        size_type max_size () const {
            return ALLOC ().max_size();
        }

       
        bool empty () const {
            return size_ == 0;
        }

       
        size_type size () const {
            return size_;
        }


       
        const_reference operator [] (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 373 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }
       
        reference operator [] (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 378 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }


       
        bounded_array &operator = (const bounded_array &a) {
            if (this != &a) {
                resize (a.size_);
                std::copy (a.data_, a.data_ + a.size_, data_);
            }
            return *this;
        }
       
        bounded_array &assign_temporary (bounded_array &a) {
            *this = a;
            return *this;
        }


       
        void swap (bounded_array &a) {
            if (this != &a) {
                std::swap (size_, a.size_);
                std::swap_ranges (data_, data_ + (std::max) (size_, a.size_), a.data_);
            }
        }
       
        friend void swap (bounded_array &a1, bounded_array &a2) {
            a1.swap (a2);
        }

       
        const_iterator begin () const {
            return data_;
        }
       
        const_iterator end () const {
            return data_ + size_;
        }

       
        iterator begin () {
            return data_;
        }
       
        iterator end () {
            return data_ + size_;
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
        typedef std::reverse_iterator<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:

        friend class boost::serialization::access;

        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            serialization::collection_size_type s(size_);
            ar & serialization::make_nvp("size", s);
            if ( Archive::is_loading::value ) {
                if (s > N) bad_size("too large size in bounded_array::load()\n").raise();
                resize(s);
            }
            ar & serialization::make_array(data_, s);
        }

    private:
        size_type size_;
        value_type data_ [N];
    };



    template<class T>
    class array_adaptor:
        public storage_array<array_adaptor<T> > {

        typedef array_adaptor<T> self_type;
    public:
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const T *const_pointer;
        typedef T *pointer;


       
        array_adaptor ():
            size_ (0), own_ (true), data_ (new value_type [0]) {
        }
        explicit
        array_adaptor (size_type size):
            size_ (size), own_ (true), data_ (new value_type [size]) {
        }
       
        array_adaptor (size_type size, const value_type &init):
            size_ (size), own_ (true), data_ (new value_type [size]) {
            std::fill (data_, data_ + size_, init);
        }
       
        array_adaptor (size_type size, pointer data):
            size_ (size), own_ (false), data_ (data) {}
       
        array_adaptor (const array_adaptor &a):
            storage_array<self_type> (),
            size_ (a.size_), own_ (true), data_ (new value_type [a.size_]) {
            *this = a;
        }
       
        ~array_adaptor () {
            if (own_) {
                delete [] data_;
            }
        }


    private:
       
        void resize_internal (size_type size, value_type init, bool preserve = true) {
           if (size != size_) {
                pointer data = new value_type [size];
                if (preserve) {
                    std::copy (data_, data_ + (std::min) (size, size_), data);
                    std::fill (data + (std::min) (size, size_), data + size, init);
                }
                if (own_)
                    delete [] data_;
                size_ = size;
                own_ = true;
                data_ = data;
            }
        }
       
        void resize_internal (size_type size, pointer data, value_type init, bool preserve = true) {
            if (data != data_) {
                if (preserve) {
                    std::copy (data_, data_ + (std::min) (size, size_), data);
                    std::fill (data + (std::min) (size, size_), data + size, init);
                }
                if (own_)
                    delete [] data_;
                own_ = false;
                data_ = data;
            }
            else {
                std::fill (data + (std::min) (size, size_), data + size, init);
            }
            size_ = size;
        }
    public:
       
        void resize (size_type size) {
            resize_internal (size, value_type (), false);
        }
       
        void resize (size_type size, value_type init) {
            resize_internal (size, init, true);
        }
       
        void resize (size_type size, pointer data) {
            resize_internal (size, data, value_type (), false);
        }
       
        void resize (size_type size, pointer data, value_type init) {
            resize_internal (size, data, init, true);
        }

       
        size_type size () const {
            return size_;
        }


       
        const_reference operator [] (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 576 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }
       
        reference operator [] (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 581 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }


       
        array_adaptor &operator = (const array_adaptor &a) {
            if (this != &a) {
                resize (a.size_);
                std::copy (a.data_, a.data_ + a.size_, data_);
            }
            return *this;
        }
       
        array_adaptor &assign_temporary (array_adaptor &a) {
            if (own_ && a.own_)
                swap (a);
            else
                *this = a;
            return *this;
        }


       
        void swap (array_adaptor &a) {
            if (this != &a) {
                std::swap (size_, a.size_);
                std::swap (own_, a.own_);
                std::swap (data_, a.data_);
            }
        }
       
        friend void swap (array_adaptor &a1, array_adaptor &a2) {
            a1.swap (a2);
        }



        typedef const_pointer const_iterator;

       
        const_iterator begin () const {
            return data_;
        }
       
        const_iterator end () const {
            return data_ + size_;
        }

        typedef pointer iterator;

       
        iterator begin () {
            return data_;
        }
       
        iterator end () {
            return data_ + size_;
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
        typedef std::reverse_iterator<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        size_type size_;
        bool own_;
        pointer data_;
    };
# 868 "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp"
    template <class Z, class D>
    class basic_range {
        typedef basic_range<Z, D> self_type;
    public:
        typedef Z size_type;
        typedef D difference_type;
        typedef size_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const value_type *const_pointer;
        typedef value_type *pointer;


       
        basic_range ():
            start_ (0), size_ (0) {}
       
        basic_range (size_type start, size_type stop):
            start_ (start), size_ (stop - start) {
            if (! (start_ <= stop)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 887 << ":" << std::endl; std::cerr << "start_ <= stop" << std::endl; bad_index ().raise (); };
        }

       
        size_type start () const {
            return start_;
        }
       
        size_type size () const {
            return size_;
        }


       
        size_type max_size () const {
            return size_;
        }

       
        bool empty () const {
            return size_ == 0;
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 913 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return start_ + i;
        }


       
        basic_range compose (const basic_range &r) const {
            return basic_range (start_ + r.start_, start_ + r.start_ + r.size_);
        }


       
        bool operator == (const basic_range &r) const {
            return start_ == r.start_ && size_ == r.size_;
        }
       
        bool operator != (const basic_range &r) const {
            return ! (*this == r);
        }


    private:

        typedef size_type const_subiterator_type;

    public:



        class const_iterator:
            public container_const_reference<basic_range>,
            public random_access_iterator_base<std::random_access_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename basic_range::value_type value_type;
            typedef typename basic_range::difference_type difference_type;
            typedef typename basic_range::const_reference reference;
            typedef typename basic_range::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<basic_range> (), it_ () {}
           
            const_iterator (const basic_range &r, const const_subiterator_type &it):
                container_const_reference<basic_range> (r), it_ (it) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                if (! (it_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 968 << ":" << std::endl; std::cerr << "it_ > 0" << std::endl; bad_index ().raise (); };
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                if (! (n >= 0 || it_ >= size_type(-n))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 974 << ":" << std::endl; std::cerr << "n >= 0 || it_ >= size_type(-n)" << std::endl; bad_index ().raise (); };
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                if (! (n <= 0 || it_ >= size_type(n))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 980 << ":" << std::endl; std::cerr << "n <= 0 || it_ >= size_type(n)" << std::endl; bad_index ().raise (); };
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! ((*this) ().start () <= it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 992 << ":" << std::endl; std::cerr << "(*this) ().start () <= it_" << std::endl; bad_index ().raise (); };
                if (! (it_ < (*this) ().start () + (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 993 << ":" << std::endl; std::cerr << "it_ < (*this) ().start () + (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return it_;
            }

           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                if (! ((*this) ().start () <= it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1005 << ":" << std::endl; std::cerr << "(*this) ().start () <= it_" << std::endl; bad_index ().raise (); };
                if (! (it_ < (*this) ().start () + (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1006 << ":" << std::endl; std::cerr << "it_ < (*this) ().start () + (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return it_ - (*this) ().start ();
            }


           
            const_iterator &operator = (const const_iterator &it) {

                this->assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1022 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1027 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return const_iterator (*this, start_);
        }
       
        const_iterator end () const {
            return const_iterator (*this, start_ + size_);
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

       
        basic_range preprocess (size_type size) const {
            if (this != &all_)
                return *this;
            return basic_range (0, size);
        }
        static
       
        const basic_range &all () {
            return all_;
        }

    private:
        size_type start_;
        size_type size_;
        static const basic_range all_;
    };

    template <class Z, class D>
    const basic_range<Z,D> basic_range<Z,D>::all_ (0, size_type (-1));



    template <class Z, class D>
    class basic_slice {
        typedef basic_slice<Z, D> self_type;
    public:
        typedef Z size_type;
        typedef D difference_type;
        typedef size_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const value_type *const_pointer;
        typedef value_type *pointer;


       
        basic_slice ():
            start_ (0), stride_ (0), size_ (0) {}
       
        basic_slice (size_type start, difference_type stride, size_type size):
            start_ (start), stride_ (stride), size_ (size) {}

       
        size_type start () const {
            return start_;
        }
       
        difference_type stride () const {
            return stride_;
        }
       
        size_type size () const {
            return size_;
        }


       
        size_type max_size () const {
            return size_;
        }

       
        bool empty () const {
            return size_ == 0;
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1127 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            if (! (stride_ >= 0 || start_ >= i * -stride_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1128 << ":" << std::endl; std::cerr << "stride_ >= 0 || start_ >= i * -stride_" << std::endl; bad_index ().raise (); };
            return start_ + i * stride_;
        }


       
        basic_slice compose (const basic_range<size_type, difference_type> &r) const {
            if (! (stride_ >=0 || start_ >= -stride_ * r.start())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1135 << ":" << std::endl; std::cerr << "stride_ >=0 || start_ >= -stride_ * r.start()" << std::endl; bad_index ().raise (); };
            return basic_slice (start_ + stride_ * r.start (), stride_, r.size ());
        }
       
        basic_slice compose (const basic_slice &s) const {
            if (! (stride_ >=0 || start_ >= -stride_ * s.start_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1140 << ":" << std::endl; std::cerr << "stride_ >=0 || start_ >= -stride_ * s.start_" << std::endl; bad_index ().raise (); };
            return basic_slice (start_ + stride_ * s.start_, stride_ * s.stride_, s.size_);
        }


       
        bool operator == (const basic_slice &s) const {
            return start_ == s.start_ && stride_ == s.stride_ && size_ == s.size_;
        }
       
        bool operator != (const basic_slice &s) const {
            return ! (*this == s);
        }


    private:

        typedef size_type const_subiterator_type;

    public:



        class const_iterator:
            public container_const_reference<basic_slice>,
            public random_access_iterator_base<std::random_access_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename basic_slice::value_type value_type;
            typedef typename basic_slice::difference_type difference_type;
            typedef typename basic_slice::const_reference reference;
            typedef typename basic_slice::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<basic_slice> (), it_ () {}
           
            const_iterator (const basic_slice &s, const const_subiterator_type &it):
                container_const_reference<basic_slice> (s), it_ (it) {}


           
            const_iterator &operator ++ () {
                ++it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                if (! (it_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1189 << ":" << std::endl; std::cerr << "it_ > 0" << std::endl; bad_index ().raise (); };
                --it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                if (! (n >= 0 || it_ >= size_type(-n))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1195 << ":" << std::endl; std::cerr << "n >= 0 || it_ >= size_type(-n)" << std::endl; bad_index ().raise (); };
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                if (! (n <= 0 || it_ >= size_type(n))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1201 << ":" << std::endl; std::cerr << "n <= 0 || it_ >= size_type(n)" << std::endl; bad_index ().raise (); };
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (it_ < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1213 << ":" << std::endl; std::cerr << "it_ < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().start () + it_* (*this) ().stride ();
            }

           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                if (! (it_ < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1225 << ":" << std::endl; std::cerr << "it_ < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return it_;
            }


           
            const_iterator &operator = (const const_iterator &it) {

                this->assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1241 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1246 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return const_iterator (*this, 0);
        }
       
        const_iterator end () const {
            return const_iterator (*this, size_);
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

       
        basic_slice preprocess (size_type size) const {
            if (this != &all_)
                return *this;
            return basic_slice (0, 1, size);
        }
        static
       
        const basic_slice &all () {
            return all_;
        }

    private:
        size_type start_;
        difference_type stride_;
        size_type size_;
        static const basic_slice all_;
    };

    template <class Z, class D>
    const basic_slice<Z,D> basic_slice<Z,D>::all_ (0, 1, size_type (-1));



    template<class A>
    class indirect_array {
        typedef indirect_array<A> self_type;
    public:
        typedef A array_type;
        typedef const A const_array_type;
        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef typename A::value_type value_type;
        typedef typename A::const_reference const_reference;
        typedef typename A::reference reference;
        typedef typename A::const_pointer const_pointer;
        typedef typename A::pointer pointer;


       
        indirect_array ():
            size_ (), data_ () {}
        explicit
        indirect_array (size_type size):
            size_ (size), data_ (size) {}
       
        indirect_array (size_type size, const array_type &data):
            size_ (size), data_ (data) {}
       
        indirect_array (pointer start, pointer stop):
            size_ (stop - start), data_ (stop - start) {
            std::copy (start, stop, data_.begin ());
        }

       
        size_type size () const {
            return size_;
        }
       
        const_array_type data () const {
            return data_;
        }
       
        array_type data () {
            return data_;
        }


       
        size_type max_size () const {
            return size_;
        }

       
        bool empty () const {
            return data_.size () == 0;
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1357 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }
       
        reference operator () (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1362 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        indirect_array compose (const basic_range<size_type, difference_type> &r) const {
            if (! (r.start () + r.size () <= size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1378 << ":" << std::endl; std::cerr << "r.start () + r.size () <= size_" << std::endl; bad_size ().raise (); };
            array_type data (r.size ());
            for (size_type i = 0; i < r.size (); ++ i)
                data [i] = data_ [r.start () + i];
            return indirect_array (r.size (), data);
        }
       
        indirect_array compose (const basic_slice<size_type, difference_type> &s) const {
            if (! (s.start () + s.stride () * (s.size () - (s.size () > 0)) <= size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1386 << ":" << std::endl; std::cerr << "s.start () + s.stride () * (s.size () - (s.size () > 0)) <= size ()" << std::endl; bad_size ().raise (); };
            array_type data (s.size ());
            for (size_type i = 0; i < s.size (); ++ i)
                data [i] = data_ [s.start () + s.stride () * i];
            return indirect_array (s.size (), data);
        }
       
        indirect_array compose (const indirect_array &ia) const {
            array_type data (ia.size_);
            for (size_type i = 0; i < ia.size_; ++ i) {
                if (! (ia.data_ [i] <= size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1396 << ":" << std::endl; std::cerr << "ia.data_ [i] <= size_" << std::endl; bad_size ().raise (); };
                data [i] = data_ [ia.data_ [i]];
            }
            return indirect_array (ia.size_, data);
        }


        template<class OA>
       
        bool operator == (const indirect_array<OA> &ia) const {
            if (size_ != ia.size_)
                return false;
            for (size_type i = 0; i < same_impl_ex ((size_), (ia.size_), "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp", 1408); ++ i)
                if (data_ [i] != ia.data_ [i])
                    return false;
            return true;
        }
        template<class OA>
       
        bool operator != (const indirect_array<OA> &ia) const {
            return ! (*this == ia);
        }


    private:

        typedef difference_type const_subiterator_type;

    public:



        class const_iterator:
            public container_const_reference<indirect_array>,
            public random_access_iterator_base<std::random_access_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename indirect_array::value_type value_type;
            typedef typename indirect_array::difference_type difference_type;
            typedef typename indirect_array::const_reference reference;
            typedef typename indirect_array::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<indirect_array> (), it_ () {}
           
            const_iterator (const indirect_array &ia, const const_subiterator_type &it):
                container_const_reference<indirect_array> (ia), it_ (it) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return (*this) () (it_);
            }

           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_;
            }


           
            const_iterator &operator = (const const_iterator &it) {

                this->assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1501 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) () == it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage.hpp" << " at line " << 1506 << ":" << std::endl; std::cerr << "(*this) () == it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return const_iterator (*this, 0);
        }
       
        const_iterator end () const {
            return const_iterator (*this, size_);
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

       
        indirect_array preprocess (size_type size) const {
            if (this != &all_)
                return *this;
            indirect_array ia (size);
            for (size_type i = 0; i < size; ++ i)
               ia (i) = i;
            return ia;
        }
        static
       
        const indirect_array &all () {
            return all_;
        }

    private:
        size_type size_;
        array_type data_;
        static const indirect_array all_;
    };

    template<class A>
    const indirect_array<A> indirect_array<A>::all_;






    template <class V>
    class index_pair :
        private boost::noncopyable,
        public container_reference<V> {

        typedef index_pair<V> self_type;
    public:
        typedef typename V::size_type size_type;

       
        index_pair(V& v, size_type i) :
            container_reference<V>(v), i_(i),
            v1_(v.data1_[i]), v2_(v.data2_[i]),
            dirty_(false), is_copy_(false) {}
        
        index_pair(const self_type& rhs) :
            container_reference<V>(rhs()), i_(0),
            v1_(rhs.v1_), v2_(rhs.v2_),
            dirty_(false), is_copy_(true) {}
        
        ~index_pair() {
            if (dirty_ && (!is_copy_) ) {
                (*this)().data1_[i_] = v1_;
                (*this)().data2_[i_] = v2_;
            }
        }

       
        self_type& operator=(const self_type& rhs) {
            v1_ = rhs.v1_;
            v2_ = rhs.v2_;
            dirty_ = true;
            return *this;
        }

       
        void swap(self_type rhs) {
            self_type tmp(rhs);
            rhs = *this;
            *this = tmp;
        }
       
        friend void swap(self_type lhs, self_type rhs) {
            lhs.swap(rhs);
        }

       
        bool equal(const self_type& rhs) const {
            return (v1_ == rhs.v1_);
        }
       
        bool less(const self_type& rhs) const {
            return (v1_ < rhs.v1_);
        }
       
        friend bool operator == (const self_type& lhs, const self_type& rhs) {
            return lhs.equal(rhs);
        }
       
        friend bool operator != (const self_type& lhs, const self_type& rhs) {
            return !lhs.equal(rhs);
        }
       
        friend bool operator < (const self_type& lhs, const self_type& rhs) {
            return lhs.less(rhs);
        }
       
        friend bool operator >= (const self_type& lhs, const self_type& rhs) {
            return !lhs.less(rhs);
        }
       
        friend bool operator > (const self_type& lhs, const self_type& rhs) {
            return rhs.less(lhs);
        }
       
        friend bool operator <= (const self_type& lhs, const self_type& rhs) {
            return !rhs.less(lhs);
        }

    private:
        size_type i_;
        typename V::value1_type v1_;
        typename V::value2_type v2_;
        bool dirty_;
        bool is_copy_;
     };

    template <class V1, class V2>
    class index_pair_array:
        private boost::noncopyable {

        typedef index_pair_array<V1, V2> self_type;
    public:
        typedef typename V1::value_type value1_type;
        typedef typename V2::value_type value2_type;

        typedef typename V1::size_type size_type;
        typedef typename V1::difference_type difference_type;
        typedef index_pair<self_type> value_type;

        typedef value_type reference;
        typedef const value_type const_reference;

       
        index_pair_array(size_type size, V1& data1, V2& data2) :
              size_(size),data1_(data1),data2_(data2) {}

       
        size_type size() const {
            return size_;
        }

       
        const_reference operator () (size_type i) const {
            return value_type((*this), i);
        }
       
        reference operator () (size_type i) {
            return value_type((*this), i);
        }

        typedef indexed_iterator<self_type, std::random_access_iterator_tag> iterator;
        typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;

       
        iterator begin() {
            return iterator( (*this), 0);
        }
       
        iterator end() {
            return iterator( (*this), size());
        }

       
        const_iterator begin() const {
            return const_iterator( (*this), 0);
        }
       
        const_iterator end() const {
            return const_iterator( (*this), size());
        }


       
        bool equal(size_type i1, size_type i2) const {
            return data1_[i1] == data1_[i2];
        }
       
        bool less(size_type i1, size_type i2) const {
            return data1_[i1] < data1_[i2];
        }


       
        friend void iter_swap(const iterator& lhs, const iterator& rhs) {
            const size_type i1 = lhs.index();
            const size_type i2 = rhs.index();
            std::swap(lhs().data1_[i1], rhs().data1_[i2]);
            std::swap(lhs().data2_[i1], rhs().data2_[i2]);
        }

    private:
        size_type size_;
        V1& data1_;
        V2& data2_;


        friend class index_pair<self_type>;
    };

    template <class M>
    class index_triple :
        private boost::noncopyable,
        public container_reference<M> {

        typedef index_triple<M> self_type;
    public:
        typedef typename M::size_type size_type;

       
        index_triple(M& m, size_type i) :
            container_reference<M>(m), i_(i),
            v1_(m.data1_[i]), v2_(m.data2_[i]), v3_(m.data3_[i]),
            dirty_(false), is_copy_(false) {}
       
        index_triple(const self_type& rhs) :
            container_reference<M>(rhs()), i_(0),
            v1_(rhs.v1_), v2_(rhs.v2_), v3_(rhs.v3_),
            dirty_(false), is_copy_(true) {}
       
        ~index_triple() {
            if (dirty_ && (!is_copy_) ) {
                (*this)().data1_[i_] = v1_;
                (*this)().data2_[i_] = v2_;
                (*this)().data3_[i_] = v3_;
            }
        }

       
        self_type& operator=(const self_type& rhs) {
            v1_ = rhs.v1_;
            v2_ = rhs.v2_;
            v3_ = rhs.v3_;
            dirty_ = true;
            return *this;
        }

       
        void swap(self_type rhs) {
            self_type tmp(rhs);
            rhs = *this;
            *this = tmp;
        }
       
        friend void swap(self_type lhs, self_type rhs) {
            lhs.swap(rhs);
        }

       
        bool equal(const self_type& rhs) const {
            return ((v1_ == rhs.v1_) && (v2_ == rhs.v2_));
        }
       
        bool less(const self_type& rhs) const {
            return ((v1_ < rhs.v1_) ||
                    (v1_ == rhs.v1_ && v2_ < rhs.v2_));
        }
       
        friend bool operator == (const self_type& lhs, const self_type& rhs) {
            return lhs.equal(rhs);
        }
       
        friend bool operator != (const self_type& lhs, const self_type& rhs) {
            return !lhs.equal(rhs);
        }
       
        friend bool operator < (const self_type& lhs, const self_type& rhs) {
            return lhs.less(rhs);
        }
       
        friend bool operator >= (const self_type& lhs, const self_type& rhs) {
            return !lhs.less(rhs);
        }
       
        friend bool operator > (const self_type& lhs, const self_type& rhs) {
            return rhs.less(lhs);
        }
       
        friend bool operator <= (const self_type& lhs, const self_type& rhs) {
            return !rhs.less(lhs);
        }

    private:
        size_type i_;
        typename M::value1_type v1_;
        typename M::value2_type v2_;
        typename M::value3_type v3_;
        bool dirty_;
        bool is_copy_;
    };

    template <class V1, class V2, class V3>
    class index_triple_array:
        private boost::noncopyable {

        typedef index_triple_array<V1, V2, V3> self_type;
    public:
        typedef typename V1::value_type value1_type;
        typedef typename V2::value_type value2_type;
        typedef typename V3::value_type value3_type;

        typedef typename V1::size_type size_type;
        typedef typename V1::difference_type difference_type;
        typedef index_triple<self_type> value_type;

        typedef value_type reference;
        typedef const value_type const_reference;

       
        index_triple_array(size_type size, V1& data1, V2& data2, V3& data3) :
              size_(size),data1_(data1),data2_(data2),data3_(data3) {}

       
        size_type size() const {
            return size_;
        }

       
        const_reference operator () (size_type i) const {
            return value_type((*this), i);
        }
       
        reference operator () (size_type i) {
            return value_type((*this), i);
        }

        typedef indexed_iterator<self_type, std::random_access_iterator_tag> iterator;
        typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;

       
        iterator begin() {
            return iterator( (*this), 0);
        }
       
        iterator end() {
            return iterator( (*this), size());
        }

       
        const_iterator begin() const {
            return const_iterator( (*this), 0);
        }
       
        const_iterator end() const {
            return const_iterator( (*this), size());
        }


       
        bool equal(size_type i1, size_type i2) const {
            return ((data1_[i1] == data1_[i2]) && (data2_[i1] == data2_[i2]));
        }
       
        bool less(size_type i1, size_type i2) const {
            return ((data1_[i1] < data1_[i2]) ||
                    (data1_[i1] == data1_[i2] && data2_[i1] < data2_[i2]));
        }


       
        friend void iter_swap(const iterator& lhs, const iterator& rhs) {
            const size_type i1 = lhs.index();
            const size_type i2 = rhs.index();
            std::swap(lhs().data1_[i1], rhs().data1_[i2]);
            std::swap(lhs().data2_[i1], rhs().data2_[i2]);
            std::swap(lhs().data3_[i1], rhs().data3_[i2]);
        }

    private:
        size_type size_;
        V1& data1_;
        V2& data2_;
        V3& data3_;


        friend class index_triple<self_type>;
    };

}}}
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp"
#define _BOOST_UBLAS_VECTOR_EXPRESSION_ 

# 1 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp" 1
# 13 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp"
#define _BOOST_UBLAS_EXPRESSION_TYPE_ 



# 1 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
#define _BOOST_UBLAS_FUNCTIONAL_ 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/functional" 1 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/functional" 3
#define _GLIBCXX_FUNCTIONAL 1

       
# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/functional" 3
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" 2
# 25 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
namespace boost { namespace numeric { namespace ublas { namespace raw {
}}}}
# 39 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
namespace boost { namespace numeric { namespace ublas {




    template<class T>
    struct scalar_unary_functor {
        typedef T value_type;
        typedef typename type_traits<T>::const_reference argument_type;
        typedef typename type_traits<T>::value_type result_type;
    };

    template<class T>
    struct scalar_identity:
        public scalar_unary_functor<T> {
        typedef typename scalar_unary_functor<T>::argument_type argument_type;
        typedef typename scalar_unary_functor<T>::result_type result_type;

        static
        result_type apply (argument_type t) {
            return t;
        }
    };
    template<class T>
    struct scalar_negate:
        public scalar_unary_functor<T> {
        typedef typename scalar_unary_functor<T>::argument_type argument_type;
        typedef typename scalar_unary_functor<T>::result_type result_type;

        static
        result_type apply (argument_type t) {
            return - t;
        }
    };
    template<class T>
    struct scalar_conj:
        public scalar_unary_functor<T> {
        typedef typename scalar_unary_functor<T>::value_type value_type;
        typedef typename scalar_unary_functor<T>::argument_type argument_type;
        typedef typename scalar_unary_functor<T>::result_type result_type;

        static
        result_type apply (argument_type t) {
            return type_traits<value_type>::conj (t);
        }
    };


    template<class T>
    struct scalar_real_unary_functor {
        typedef T value_type;
        typedef typename type_traits<T>::const_reference argument_type;
        typedef typename type_traits<T>::real_type result_type;
    };

    template<class T>
    struct scalar_real:
        public scalar_real_unary_functor<T> {
        typedef typename scalar_real_unary_functor<T>::value_type value_type;
        typedef typename scalar_real_unary_functor<T>::argument_type argument_type;
        typedef typename scalar_real_unary_functor<T>::result_type result_type;

        static
        result_type apply (argument_type t) {
            return type_traits<value_type>::real (t);
        }
    };
    template<class T>
    struct scalar_imag:
        public scalar_real_unary_functor<T> {
        typedef typename scalar_real_unary_functor<T>::value_type value_type;
        typedef typename scalar_real_unary_functor<T>::argument_type argument_type;
        typedef typename scalar_real_unary_functor<T>::result_type result_type;

        static
        result_type apply (argument_type t) {
            return type_traits<value_type>::imag (t);
        }
    };


    template<class T1, class T2>
    struct scalar_binary_functor {
        typedef typename type_traits<T1>::const_reference argument1_type;
        typedef typename type_traits<T2>::const_reference argument2_type;
        typedef typename promote_traits<T1, T2>::promote_type result_type;
    };

    template<class T1, class T2>
    struct scalar_plus:
        public scalar_binary_functor<T1, T2> {
        typedef typename scalar_binary_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_functor<T1, T2>::argument2_type argument2_type;
        typedef typename scalar_binary_functor<T1, T2>::result_type result_type;

        static
        result_type apply (argument1_type t1, argument2_type t2) {
            return t1 + t2;
        }
    };
    template<class T1, class T2>
    struct scalar_minus:
        public scalar_binary_functor<T1, T2> {
        typedef typename scalar_binary_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_functor<T1, T2>::argument2_type argument2_type;
        typedef typename scalar_binary_functor<T1, T2>::result_type result_type;

        static
        result_type apply (argument1_type t1, argument2_type t2) {
            return t1 - t2;
        }
    };
    template<class T1, class T2>
    struct scalar_multiplies:
        public scalar_binary_functor<T1, T2> {
        typedef typename scalar_binary_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_functor<T1, T2>::argument2_type argument2_type;
        typedef typename scalar_binary_functor<T1, T2>::result_type result_type;

        static
        result_type apply (argument1_type t1, argument2_type t2) {
            return t1 * t2;
        }
    };
    template<class T1, class T2>
    struct scalar_divides:
        public scalar_binary_functor<T1, T2> {
        typedef typename scalar_binary_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_functor<T1, T2>::argument2_type argument2_type;
        typedef typename scalar_binary_functor<T1, T2>::result_type result_type;

        static
        result_type apply (argument1_type t1, argument2_type t2) {
            return t1 / t2;
        }
    };

    template<class T1, class T2>
    struct scalar_binary_assign_functor {

        typedef typename type_traits<typename boost::remove_reference<T1>::type>::reference argument1_type;
        typedef typename type_traits<T2>::const_reference argument2_type;
    };

    struct assign_tag {};
    struct computed_assign_tag {};

    template<class T1, class T2>
    struct scalar_assign:
        public scalar_binary_assign_functor<T1, T2> {
        typedef typename scalar_binary_assign_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_assign_functor<T1, T2>::argument2_type argument2_type;



        static const bool computed = false ;


        static
        void apply (argument1_type t1, argument2_type t2) {
            t1 = t2;
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_assign<U1, U2> other;
        };
    };






    template<class T1, class T2>
    struct scalar_plus_assign:
        public scalar_binary_assign_functor<T1, T2> {
        typedef typename scalar_binary_assign_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_assign_functor<T1, T2>::argument2_type argument2_type;



        static const bool computed = true ;


        static
        void apply (argument1_type t1, argument2_type t2) {
            t1 += t2;
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_plus_assign<U1, U2> other;
        };
    };






    template<class T1, class T2>
    struct scalar_minus_assign:
        public scalar_binary_assign_functor<T1, T2> {
        typedef typename scalar_binary_assign_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_assign_functor<T1, T2>::argument2_type argument2_type;



        static const bool computed = true ;


        static
        void apply (argument1_type t1, argument2_type t2) {
            t1 -= t2;
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_minus_assign<U1, U2> other;
        };
    };






    template<class T1, class T2>
    struct scalar_multiplies_assign:
        public scalar_binary_assign_functor<T1, T2> {
        typedef typename scalar_binary_assign_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_assign_functor<T1, T2>::argument2_type argument2_type;
        static const bool computed = true;

        static
        void apply (argument1_type t1, argument2_type t2) {
            t1 *= t2;
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_multiplies_assign<U1, U2> other;
        };
    };
    template<class T1, class T2>
    struct scalar_divides_assign:
        public scalar_binary_assign_functor<T1, T2> {
        typedef typename scalar_binary_assign_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_assign_functor<T1, T2>::argument2_type argument2_type;
        static const bool computed ;

        static
        void apply (argument1_type t1, argument2_type t2) {
            t1 /= t2;
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_divides_assign<U1, U2> other;
        };
    };
    template<class T1, class T2>
    const bool scalar_divides_assign<T1,T2>::computed = true;

    template<class T1, class T2>
    struct scalar_binary_swap_functor {
        typedef typename type_traits<typename boost::remove_reference<T1>::type>::reference argument1_type;
        typedef typename type_traits<typename boost::remove_reference<T2>::type>::reference argument2_type;
    };

    template<class T1, class T2>
    struct scalar_swap:
        public scalar_binary_swap_functor<T1, T2> {
        typedef typename scalar_binary_swap_functor<T1, T2>::argument1_type argument1_type;
        typedef typename scalar_binary_swap_functor<T1, T2>::argument2_type argument2_type;

        static
        void apply (argument1_type t1, argument2_type t2) {
            std::swap (t1, t2);
        }

        template<class U1, class U2>
        struct rebind {
            typedef scalar_swap<U1, U2> other;
        };
    };




    template<class V>
    struct vector_scalar_unary_functor {
        typedef typename V::value_type value_type;
        typedef typename V::value_type result_type;
    };

    template<class V>
    struct vector_sum:
        public vector_scalar_unary_functor<V> {
        typedef typename vector_scalar_unary_functor<V>::value_type value_type;
        typedef typename vector_scalar_unary_functor<V>::result_type result_type;

        template<class E>
        static
        result_type apply (const vector_expression<E> &e) {
            result_type t = result_type (0);
            typedef typename E::size_type vector_size_type;
            vector_size_type size (e ().size ());
            for (vector_size_type i = 0; i < size; ++ i)
                t += e () (i);
            return t;
        }

        template<class D, class I>
        static
        result_type apply (D size, I it) {
            result_type t = result_type (0);
            while (-- size >= 0)
                t += *it, ++ it;
            return t;
        }

        template<class I>
        static
        result_type apply (I it, const I &it_end) {
            result_type t = result_type (0);
            while (it != it_end)
                t += *it, ++ it;
            return t;
        }
    };


    template<class V>
    struct vector_scalar_real_unary_functor {
        typedef typename V::value_type value_type;
        typedef typename type_traits<value_type>::real_type real_type;
        typedef real_type result_type;
    };

    template<class V>
    struct vector_norm_1:
        public vector_scalar_real_unary_functor<V> {
        typedef typename vector_scalar_real_unary_functor<V>::value_type value_type;
        typedef typename vector_scalar_real_unary_functor<V>::real_type real_type;
        typedef typename vector_scalar_real_unary_functor<V>::result_type result_type;

        template<class E>
        static
        result_type apply (const vector_expression<E> &e) {
            real_type t = real_type ();
            typedef typename E::size_type vector_size_type;
            vector_size_type size (e ().size ());
            for (vector_size_type i = 0; i < size; ++ i) {
                real_type u (type_traits<value_type>::type_abs (e () (i)));
                t += u;
            }
            return t;
        }

        template<class D, class I>
        static
        result_type apply (D size, I it) {
            real_type t = real_type ();
            while (-- size >= 0) {
                real_type u (type_traits<value_type>::norm_1 (*it));
                t += u;
                ++ it;
            }
            return t;
        }

        template<class I>
        static
        result_type apply (I it, const I &it_end) {
            real_type t = real_type ();
            while (it != it_end) {
                real_type u (type_traits<value_type>::norm_1 (*it));
                t += u;
                ++ it;
            }
            return t;
        }
    };
    template<class V>
    struct vector_norm_2:
        public vector_scalar_real_unary_functor<V> {
        typedef typename vector_scalar_real_unary_functor<V>::value_type value_type;
        typedef typename vector_scalar_real_unary_functor<V>::real_type real_type;
        typedef typename vector_scalar_real_unary_functor<V>::result_type result_type;

        template<class E>
        static
        result_type apply (const vector_expression<E> &e) {

            real_type t = real_type ();
            typedef typename E::size_type vector_size_type;
            vector_size_type size (e ().size ());
            for (vector_size_type i = 0; i < size; ++ i) {
                real_type u (type_traits<value_type>::norm_2 (e () (i)));
                t += u * u;
            }
            return type_traits<real_type>::type_sqrt (t);
# 461 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
        }

        template<class D, class I>
        static
        result_type apply (D size, I it) {

            real_type t = real_type ();
            while (-- size >= 0) {
                real_type u (type_traits<value_type>::norm_2 (*it));
                t += u * u;
                ++ it;
            }
            return type_traits<real_type>::type_sqrt (t);
# 491 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
        }

        template<class I>
        static
        result_type apply (I it, const I &it_end) {

            real_type t = real_type ();
            while (it != it_end) {
                real_type u (type_traits<value_type>::norm_2 (*it));
                t += u * u;
                ++ it;
            }
            return type_traits<real_type>::type_sqrt (t);
# 521 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
        }
    };
    template<class V>
    struct vector_norm_inf:
        public vector_scalar_real_unary_functor<V> {
        typedef typename vector_scalar_real_unary_functor<V>::value_type value_type;
        typedef typename vector_scalar_real_unary_functor<V>::real_type real_type;
        typedef typename vector_scalar_real_unary_functor<V>::result_type result_type;

        template<class E>
        static
        result_type apply (const vector_expression<E> &e) {
            real_type t = real_type ();
            typedef typename E::size_type vector_size_type;
            vector_size_type size (e ().size ());
            for (vector_size_type i = 0; i < size; ++ i) {
                real_type u (type_traits<value_type>::norm_inf (e () (i)));
                if (u > t)
                    t = u;
            }
            return t;
        }

        template<class D, class I>
        static
        result_type apply (D size, I it) {
            real_type t = real_type ();
            while (-- size >= 0) {
                real_type u (type_traits<value_type>::norm_inf (*it));
                if (u > t)
                    t = u;
                ++ it;
            }
            return t;
        }

        template<class I>
        static
        result_type apply (I it, const I &it_end) {
            real_type t = real_type ();
            while (it != it_end) {
                real_type u (type_traits<value_type>::norm_inf (*it));
                if (u > t)
                    t = u;
                ++ it;
            }
            return t;
        }
    };


    template<class V>
    struct vector_scalar_index_unary_functor {
        typedef typename V::value_type value_type;
        typedef typename type_traits<value_type>::real_type real_type;
        typedef typename V::size_type result_type;
    };

    template<class V>
    struct vector_index_norm_inf:
        public vector_scalar_index_unary_functor<V> {
        typedef typename vector_scalar_index_unary_functor<V>::value_type value_type;
        typedef typename vector_scalar_index_unary_functor<V>::real_type real_type;
        typedef typename vector_scalar_index_unary_functor<V>::result_type result_type;

        template<class E>
        static
        result_type apply (const vector_expression<E> &e) {

            result_type i_norm_inf (0);
            real_type t = real_type ();
            typedef typename E::size_type vector_size_type;
            vector_size_type size (e ().size ());
            for (vector_size_type i = 0; i < size; ++ i) {
                real_type u (type_traits<value_type>::norm_inf (e () (i)));
                if (u > t) {
                    i_norm_inf = i;
                    t = u;
                }
            }
            return i_norm_inf;
        }

        template<class D, class I>
        static
        result_type apply (D size, I it) {

            result_type i_norm_inf (0);
            real_type t = real_type ();
            while (-- size >= 0) {
                real_type u (type_traits<value_type>::norm_inf (*it));
                if (u > t) {
                    i_norm_inf = it.index ();
                    t = u;
                }
                ++ it;
            }
            return i_norm_inf;
        }

        template<class I>
        static
        result_type apply (I it, const I &it_end) {

            result_type i_norm_inf (0);
            real_type t = real_type ();
            while (it != it_end) {
                real_type u (type_traits<value_type>::norm_inf (*it));
                if (u > t) {
                    i_norm_inf = it.index ();
                    t = u;
                }
                ++ it;
            }
            return i_norm_inf;
        }
    };


    template<class V1, class V2, class TV>
    struct vector_scalar_binary_functor {
        typedef TV value_type;
        typedef TV result_type;
    };

    template<class V1, class V2, class TV>
    struct vector_inner_prod:
        public vector_scalar_binary_functor<V1, V2, TV> {
        typedef typename vector_scalar_binary_functor<V1, V2, TV>::value_type value_type;
        typedef typename vector_scalar_binary_functor<V1, V2, TV>::result_type result_type;

        template<class C1, class C2>
        static
        result_type apply (const vector_container<C1> &c1,
                           const vector_container<C2> &c2) {
# 682 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
            return apply (static_cast<const vector_expression<C1> > (c1), static_cast<const vector_expression<C2> > (c2));

        }
        template<class E1, class E2>
        static
        result_type apply (const vector_expression<E1> &e1,
                           const vector_expression<E2> &e2) {
            typedef typename E1::size_type vector_size_type;
            vector_size_type size (same_impl_ex ((e1 ().size ()), (e2 ().size ()), "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp", 690));
            result_type t = result_type (0);

            for (vector_size_type i = 0; i < size; ++ i)
                t += e1 () (i) * e2 () (i);




            return t;
        }

        template<class D, class I1, class I2>
        static
        result_type apply (D size, I1 it1, I2 it2) {
            result_type t = result_type (0);

            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;



            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end) {
            result_type t = result_type (0);
            typedef typename I1::difference_type vector_difference_type;
            vector_difference_type it1_size (it1_end - it1);
            vector_difference_type it2_size (it2_end - it2);
            vector_difference_type diff (0);
            if (it1_size > 0 && it2_size > 0)
                diff = it2.index () - it1.index ();
            if (diff != 0) {
                vector_difference_type size = (std::min) (diff, it1_size);
                if (size > 0) {
                    it1 += size;
                    it1_size -= size;
                    diff -= size;
                }
                size = (std::min) (- diff, it2_size);
                if (size > 0) {
                    it2 += size;
                    it2_size -= size;
                    diff += size;
                }
            }
            vector_difference_type size ((std::min) (it1_size, it2_size));
            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            if (it1 != it1_end && it2 != it2_end) {
                while (true) {
                    if (it1.index () == it2.index ()) {
                        t += *it1 * *it2, ++ it1, ++ it2;
                        if (it1 == it1_end || it2 == it2_end)
                            break;
                    } else if (it1.index () < it2.index ()) {
                        increment (it1, it1_end, it2.index () - it1.index ());
                        if (it1 == it1_end)
                            break;
                    } else if (it1.index () > it2.index ()) {
                        increment (it2, it2_end, it1.index () - it2.index ());
                        if (it2 == it2_end)
                            break;
                    }
                }
            }
            return t;
        }
    };




    template<class M1, class M2, class TV>
    struct matrix_vector_binary_functor {
        typedef typename M1::size_type size_type;
        typedef typename M1::difference_type difference_type;
        typedef TV value_type;
        typedef TV result_type;
    };

    template<class M1, class M2, class TV>
    struct matrix_vector_prod1:
        public matrix_vector_binary_functor<M1, M2, TV> {
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::size_type size_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::difference_type difference_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::value_type value_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::result_type result_type;

        template<class C1, class C2>
        static
        result_type apply (const matrix_container<C1> &c1,
                           const vector_container<C2> &c2,
                           size_type i) {
# 819 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
            return apply (static_cast<const matrix_expression<C1> > (c1), static_cast<const vector_expression<C2> > (c2, i));

        }
        template<class E1, class E2>
        static
        result_type apply (const matrix_expression<E1> &e1,
                           const vector_expression<E2> &e2,
                           size_type i) {
            size_type size = same_impl_ex ((e1 ().size2 ()), (e2 ().size ()), "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp", 827);
            result_type t = result_type (0);

            for (size_type j = 0; j < size; ++ j)
                t += e1 () (i, j) * e2 () (j);




            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (difference_type size, I1 it1, I2 it2) {
            result_type t = result_type (0);

            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;



            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end) {
            result_type t = result_type (0);
            difference_type it1_size (it1_end - it1);
            difference_type it2_size (it2_end - it2);
            difference_type diff (0);
            if (it1_size > 0 && it2_size > 0)
                diff = it2.index () - it1.index2 ();
            if (diff != 0) {
                difference_type size = (std::min) (diff, it1_size);
                if (size > 0) {
                    it1 += size;
                    it1_size -= size;
                    diff -= size;
                }
                size = (std::min) (- diff, it2_size);
                if (size > 0) {
                    it2 += size;
                    it2_size -= size;
                    diff += size;
                }
            }
            difference_type size ((std::min) (it1_size, it2_size));
            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end,
                           sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            if (it1 != it1_end && it2 != it2_end) {
                size_type it1_index = it1.index2 (), it2_index = it2.index ();
                while (true) {
                    difference_type compare = it1_index - it2_index;
                    if (compare == 0) {
                        t += *it1 * *it2, ++ it1, ++ it2;
                        if (it1 != it1_end && it2 != it2_end) {
                            it1_index = it1.index2 ();
                            it2_index = it2.index ();
                        } else
                            break;
                    } else if (compare < 0) {
                        increment (it1, it1_end, - compare);
                        if (it1 != it1_end)
                            it1_index = it1.index2 ();
                        else
                            break;
                    } else if (compare > 0) {
                        increment (it2, it2_end, compare);
                        if (it2 != it2_end)
                            it2_index = it2.index ();
                        else
                            break;
                    }
                }
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 & ,
                           sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag) {
            result_type t = result_type (0);
            while (it1 != it1_end) {
                t += *it1 * it2 () (it1.index2 ());
                ++ it1;
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 & , I2 it2, const I2 &it2_end,
                           packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            while (it2 != it2_end) {
                t += it1 () (it1.index1 (), it2.index ()) * *it2;
                ++ it2;
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end,
                           sparse_bidirectional_iterator_tag) {
            typedef typename I1::iterator_category iterator1_category;
            typedef typename I2::iterator_category iterator2_category;
            return apply (it1, it1_end, it2, it2_end, iterator1_category (), iterator2_category ());
        }
    };

    template<class M1, class M2, class TV>
    struct matrix_vector_prod2:
        public matrix_vector_binary_functor<M1, M2, TV> {
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::size_type size_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::difference_type difference_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::value_type value_type;
        typedef typename matrix_vector_binary_functor<M1, M2, TV>::result_type result_type;

        template<class C1, class C2>
        static
        result_type apply (const vector_container<C1> &c1,
                           const matrix_container<C2> &c2,
                           size_type i) {
# 987 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
            return apply (static_cast<const vector_expression<C1> > (c1), static_cast<const matrix_expression<C2> > (c2, i));

        }
        template<class E1, class E2>
        static
        result_type apply (const vector_expression<E1> &e1,
                           const matrix_expression<E2> &e2,
                           size_type i) {
            size_type size = same_impl_ex ((e1 ().size ()), (e2 ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp", 995);
            result_type t = result_type (0);

            for (size_type j = 0; j < size; ++ j)
                t += e1 () (j) * e2 () (j, i);




            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (difference_type size, I1 it1, I2 it2) {
            result_type t = result_type (0);

            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;



            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end) {
            result_type t = result_type (0);
            difference_type it1_size (it1_end - it1);
            difference_type it2_size (it2_end - it2);
            difference_type diff (0);
            if (it1_size > 0 && it2_size > 0)
                diff = it2.index1 () - it1.index ();
            if (diff != 0) {
                difference_type size = (std::min) (diff, it1_size);
                if (size > 0) {
                    it1 += size;
                    it1_size -= size;
                    diff -= size;
                }
                size = (std::min) (- diff, it2_size);
                if (size > 0) {
                    it2 += size;
                    it2_size -= size;
                    diff += size;
                }
            }
            difference_type size ((std::min) (it1_size, it2_size));
            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end,
                           sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            if (it1 != it1_end && it2 != it2_end) {
                size_type it1_index = it1.index (), it2_index = it2.index1 ();
                while (true) {
                    difference_type compare = it1_index - it2_index;
                    if (compare == 0) {
                        t += *it1 * *it2, ++ it1, ++ it2;
                        if (it1 != it1_end && it2 != it2_end) {
                            it1_index = it1.index ();
                            it2_index = it2.index1 ();
                        } else
                            break;
                    } else if (compare < 0) {
                        increment (it1, it1_end, - compare);
                        if (it1 != it1_end)
                            it1_index = it1.index ();
                        else
                            break;
                    } else if (compare > 0) {
                        increment (it2, it2_end, compare);
                        if (it2 != it2_end)
                            it2_index = it2.index1 ();
                        else
                            break;
                    }
                }
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 & , I2 it2, const I2 &it2_end,
                           packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            while (it2 != it2_end) {
                t += it1 () (it2.index1 ()) * *it2;
                ++ it2;
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 & ,
                           sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag) {
            result_type t = result_type (0);
            while (it1 != it1_end) {
                t += *it1 * it2 () (it1.index (), it2.index2 ());
                ++ it1;
            }
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end,
                           sparse_bidirectional_iterator_tag) {
            typedef typename I1::iterator_category iterator1_category;
            typedef typename I2::iterator_category iterator2_category;
            return apply (it1, it1_end, it2, it2_end, iterator1_category (), iterator2_category ());
        }
    };


    template<class M1, class M2, class TV>
    struct matrix_matrix_binary_functor {
        typedef typename M1::size_type size_type;
        typedef typename M1::difference_type difference_type;
        typedef TV value_type;
        typedef TV result_type;
    };

    template<class M1, class M2, class TV>
    struct matrix_matrix_prod:
        public matrix_matrix_binary_functor<M1, M2, TV> {
        typedef typename matrix_matrix_binary_functor<M1, M2, TV>::size_type size_type;
        typedef typename matrix_matrix_binary_functor<M1, M2, TV>::difference_type difference_type;
        typedef typename matrix_matrix_binary_functor<M1, M2, TV>::value_type value_type;
        typedef typename matrix_matrix_binary_functor<M1, M2, TV>::result_type result_type;

        template<class C1, class C2>
        static
        result_type apply (const matrix_container<C1> &c1,
                           const matrix_container<C2> &c2,
                           size_type i, size_type j) {
# 1164 "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp"
            return apply (static_cast<const matrix_expression<C1> > (c1), static_cast<const matrix_expression<C2> > (c2, i));

        }
        template<class E1, class E2>
        static
        result_type apply (const matrix_expression<E1> &e1,
                           const matrix_expression<E2> &e2,
                           size_type i, size_type j) {
            size_type size = same_impl_ex ((e1 ().size2 ()), (e2 ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp", 1172);
            result_type t = result_type (0);

            for (size_type k = 0; k < size; ++ k)
                t += e1 () (i, k) * e2 () (k, j);




            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (difference_type size, I1 it1, I2 it2) {
            result_type t = result_type (0);

            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;



            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, packed_random_access_iterator_tag) {
            result_type t = result_type (0);
            difference_type it1_size (it1_end - it1);
            difference_type it2_size (it2_end - it2);
            difference_type diff (0);
            if (it1_size > 0 && it2_size > 0)
                diff = it2.index1 () - it1.index2 ();
            if (diff != 0) {
                difference_type size = (std::min) (diff, it1_size);
                if (size > 0) {
                    it1 += size;
                    it1_size -= size;
                    diff -= size;
                }
                size = (std::min) (- diff, it2_size);
                if (size > 0) {
                    it2 += size;
                    it2_size -= size;
                    diff += size;
                }
            }
            difference_type size ((std::min) (it1_size, it2_size));
            while (-- size >= 0)
                t += *it1 * *it2, ++ it1, ++ it2;
            return t;
        }

        template<class I1, class I2>
        static
        result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag) {
            result_type t = result_type (0);
            if (it1 != it1_end && it2 != it2_end) {
                size_type it1_index = it1.index2 (), it2_index = it2.index1 ();
                while (true) {
                    difference_type compare = difference_type (it1_index - it2_index);
                    if (compare == 0) {
                        t += *it1 * *it2, ++ it1, ++ it2;
                        if (it1 != it1_end && it2 != it2_end) {
                            it1_index = it1.index2 ();
                            it2_index = it2.index1 ();
                        } else
                            break;
                    } else if (compare < 0) {
                        increment (it1, it1_end, - compare);
                        if (it1 != it1_end)
                            it1_index = it1.index2 ();
                        else
                            break;
                    } else if (compare > 0) {
                        increment (it2, it2_end, compare);
                        if (it2 != it2_end)
                            it2_index = it2.index1 ();
                        else
                            break;
                    }
                }
            }
            return t;
        }
    };


    template<class M>
    struct matrix_scalar_real_unary_functor {
        typedef typename M::value_type value_type;
        typedef typename type_traits<value_type>::real_type real_type;
        typedef real_type result_type;
    };

    template<class M>
    struct matrix_norm_1:
        public matrix_scalar_real_unary_functor<M> {
        typedef typename matrix_scalar_real_unary_functor<M>::value_type value_type;
        typedef typename matrix_scalar_real_unary_functor<M>::real_type real_type;
        typedef typename matrix_scalar_real_unary_functor<M>::result_type result_type;

        template<class E>
        static
        result_type apply (const matrix_expression<E> &e) {
            real_type t = real_type ();
            typedef typename E::size_type matrix_size_type;
            matrix_size_type size2 (e ().size2 ());
            for (matrix_size_type j = 0; j < size2; ++ j) {
                real_type u = real_type ();
                matrix_size_type size1 (e ().size1 ());
                for (matrix_size_type i = 0; i < size1; ++ i) {
                    real_type v (type_traits<value_type>::norm_1 (e () (i, j)));
                    u += v;
                }
                if (u > t)
                    t = u;
            }
            return t;
        }
    };

    template<class M>
    struct matrix_norm_frobenius:
        public matrix_scalar_real_unary_functor<M> {
        typedef typename matrix_scalar_real_unary_functor<M>::value_type value_type;
        typedef typename matrix_scalar_real_unary_functor<M>::real_type real_type;
        typedef typename matrix_scalar_real_unary_functor<M>::result_type result_type;

        template<class E>
        static
        result_type apply (const matrix_expression<E> &e) {
            real_type t = real_type ();
            typedef typename E::size_type matrix_size_type;
            matrix_size_type size1 (e ().size1 ());
            for (matrix_size_type i = 0; i < size1; ++ i) {
                matrix_size_type size2 (e ().size2 ());
                for (matrix_size_type j = 0; j < size2; ++ j) {
                    real_type u (type_traits<value_type>::norm_2 (e () (i, j)));
                    t += u * u;
                }
            }
            return type_traits<real_type>::type_sqrt (t);
        }
    };

    template<class M>
    struct matrix_norm_inf:
        public matrix_scalar_real_unary_functor<M> {
        typedef typename matrix_scalar_real_unary_functor<M>::value_type value_type;
        typedef typename matrix_scalar_real_unary_functor<M>::real_type real_type;
        typedef typename matrix_scalar_real_unary_functor<M>::result_type result_type;

        template<class E>
        static
        result_type apply (const matrix_expression<E> &e) {
            real_type t = real_type ();
            typedef typename E::size_type matrix_size_type;
            matrix_size_type size1 (e ().size1 ());
            for (matrix_size_type i = 0; i < size1; ++ i) {
                real_type u = real_type ();
                matrix_size_type size2 (e ().size2 ());
                for (matrix_size_type j = 0; j < size2; ++ j) {
                    real_type v (type_traits<value_type>::norm_inf (e () (i, j)));
                    u += v;
                }
                if (u > t)
                    t = u;
            }
            return t;
        }
    };


    template <class Z, class D> struct basic_column_major;



    template <class Z, class D>
    struct basic_row_major {
        typedef Z size_type;
        typedef D difference_type;
        typedef row_major_tag orientation_category;
        typedef basic_column_major<Z,D> transposed_layout;

        static
       
        size_type storage_size (size_type size_i, size_type size_j) {

            if (! (size_j == 0 || size_i <= (std::numeric_limits<size_type>::max) () / size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1362 << ":" << std::endl; std::cerr << "size_j == 0 || size_i <= (std::numeric_limits<size_type>::max) () / size_j" << std::endl; bad_size ().raise (); };
            return size_i * size_j;
        }


        static
       
        size_type element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1370 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1371 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            detail::ignore_unused_variable_warning(size_i);

            if (! (i <= ((std::numeric_limits<size_type>::max) () - j) / size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1374 << ":" << std::endl; std::cerr << "i <= ((std::numeric_limits<size_type>::max) () - j) / size_j" << std::endl; bad_index ().raise (); };
            return i * size_j + j;
        }
        static
       
        size_type address (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i <= size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1380 << ":" << std::endl; std::cerr << "i <= size_i" << std::endl; bad_index ().raise (); };
            if (! (j <= size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1381 << ":" << std::endl; std::cerr << "j <= size_j" << std::endl; bad_index ().raise (); };

            if (! (size_j == 0 || i <= ((std::numeric_limits<size_type>::max) () - j) / size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1383 << ":" << std::endl; std::cerr << "size_j == 0 || i <= ((std::numeric_limits<size_type>::max) () - j) / size_j" << std::endl; bad_index ().raise (); };
            detail::ignore_unused_variable_warning(size_i);
            return i * size_j + j;
        }


        static
       
        difference_type distance_i (difference_type k, size_type , size_type size_j) {
            return size_j != 0 ? k / size_j : 0;
        }
        static
       
        difference_type distance_j (difference_type k, size_type , size_type ) {
            return k;
        }
        static
       
        size_type index_i (difference_type k, size_type , size_type size_j) {
            return size_j != 0 ? k / size_j : 0;
        }
        static
       
        size_type index_j (difference_type k, size_type , size_type size_j) {
            return size_j != 0 ? k % size_j : 0;
        }
        static
       
        bool fast_i () {
            return false;
        }
        static
       
        bool fast_j () {
            return true;
        }


        template<class I>
        static
       
        void increment_i (I &it, size_type , size_type size_j) {
            it += size_j;
        }
        template<class I>
        static
       
        void increment_i (I &it, difference_type n, size_type , size_type size_j) {
            it += n * size_j;
        }
        template<class I>
        static
       
        void decrement_i (I &it, size_type , size_type size_j) {
            it -= size_j;
        }
        template<class I>
        static
       
        void decrement_i (I &it, difference_type n, size_type , size_type size_j) {
            it -= n * size_j;
        }
        template<class I>
        static
       
        void increment_j (I &it, size_type , size_type ) {
            ++ it;
        }
        template<class I>
        static
       
        void increment_j (I &it, difference_type n, size_type , size_type ) {
            it += n;
        }
        template<class I>
        static
       
        void decrement_j (I &it, size_type , size_type ) {
            -- it;
        }
        template<class I>
        static
       
        void decrement_j (I &it, difference_type n, size_type , size_type ) {
            it -= n;
        }


        static
       
        size_type triangular_size (size_type size_i, size_type size_j) {
            size_type size = (std::max) (size_i, size_j);

            if (! (size == 0 || size / 2 < (std::numeric_limits<size_type>::max) () / size)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1476 << ":" << std::endl; std::cerr << "size == 0 || size / 2 < (std::numeric_limits<size_type>::max) () / size" << std::endl; bad_size ().raise (); };
            return ((size + 1) * size) / 2;
        }
        static
       
        size_type lower_element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1482 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1483 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            if (! (i >= j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1484 << ":" << std::endl; std::cerr << "i >= j" << std::endl; bad_index ().raise (); };
            detail::ignore_unused_variable_warning(size_i);
            detail::ignore_unused_variable_warning(size_j);



            return ((i + 1) * i) / 2 + j;
        }
        static
       
        size_type upper_element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1495 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1496 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            if (! (i <= j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1497 << ":" << std::endl; std::cerr << "i <= j" << std::endl; bad_index ().raise (); };



            return (i * (2 * (std::max) (size_i, size_j) - i + 1)) / 2 + j - i;
        }


        static
       
        size_type index_M (size_type index1, size_type ) {
            return index1;
        }
        static
       
        size_type index_m (size_type , size_type index2) {
            return index2;
        }
        static
       
        size_type size_M (size_type size_i, size_type ) {
            return size_i;
        }
        static
       
        size_type size_m (size_type , size_type size_j) {
            return size_j;
        }
    };



    template <class Z, class D>
    struct basic_column_major {
        typedef Z size_type;
        typedef D difference_type;
        typedef column_major_tag orientation_category;
        typedef basic_row_major<Z,D> transposed_layout;

        static
       
        size_type storage_size (size_type size_i, size_type size_j) {

            if (! (size_i == 0 || size_j <= (std::numeric_limits<size_type>::max) () / size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1540 << ":" << std::endl; std::cerr << "size_i == 0 || size_j <= (std::numeric_limits<size_type>::max) () / size_i" << std::endl; bad_size ().raise (); };
            return size_i * size_j;
        }


        static
       
        size_type element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1548 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1549 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            detail::ignore_unused_variable_warning(size_j);

            if (! (j <= ((std::numeric_limits<size_type>::max) () - i) / size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1552 << ":" << std::endl; std::cerr << "j <= ((std::numeric_limits<size_type>::max) () - i) / size_i" << std::endl; bad_index ().raise (); };
            return i + j * size_i;
        }
        static
       
        size_type address (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i <= size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1558 << ":" << std::endl; std::cerr << "i <= size_i" << std::endl; bad_index ().raise (); };
            if (! (j <= size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1559 << ":" << std::endl; std::cerr << "j <= size_j" << std::endl; bad_index ().raise (); };
            detail::ignore_unused_variable_warning(size_j);

            if (! (size_i == 0 || j <= ((std::numeric_limits<size_type>::max) () - i) / size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1562 << ":" << std::endl; std::cerr << "size_i == 0 || j <= ((std::numeric_limits<size_type>::max) () - i) / size_i" << std::endl; bad_index ().raise (); };
            return i + j * size_i;
        }


        static
       
        difference_type distance_i (difference_type k, size_type , size_type ) {
            return k;
        }
        static
       
        difference_type distance_j (difference_type k, size_type size_i, size_type ) {
            return size_i != 0 ? k / size_i : 0;
        }
        static
       
        size_type index_i (difference_type k, size_type size_i, size_type ) {
            return size_i != 0 ? k % size_i : 0;
        }
        static
       
        size_type index_j (difference_type k, size_type size_i, size_type ) {
            return size_i != 0 ? k / size_i : 0;
        }
        static
       
        bool fast_i () {
            return true;
        }
        static
       
        bool fast_j () {
            return false;
        }


        template<class I>
        static
       
        void increment_i (I &it, size_type , size_type ) {
            ++ it;
        }
        template<class I>
        static
       
        void increment_i (I &it, difference_type n, size_type , size_type ) {
            it += n;
        }
        template<class I>
        static
       
        void decrement_i (I &it, size_type , size_type ) {
            -- it;
        }
        template<class I>
        static
       
        void decrement_i (I &it, difference_type n, size_type , size_type ) {
            it -= n;
        }
        template<class I>
        static
       
        void increment_j (I &it, size_type size_i, size_type ) {
            it += size_i;
        }
        template<class I>
        static
       
        void increment_j (I &it, difference_type n, size_type size_i, size_type ) {
            it += n * size_i;
        }
        template<class I>
        static
       
        void decrement_j (I &it, size_type size_i, size_type ) {
            it -= size_i;
        }
        template<class I>
        static
       
        void decrement_j (I &it, difference_type n, size_type size_i, size_type ) {
            it -= n* size_i;
        }


        static
       
        size_type triangular_size (size_type size_i, size_type size_j) {
            size_type size = (std::max) (size_i, size_j);

            if (! (size == 0 || size / 2 < (std::numeric_limits<size_type>::max) () / size)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1654 << ":" << std::endl; std::cerr << "size == 0 || size / 2 < (std::numeric_limits<size_type>::max) () / size" << std::endl; bad_size ().raise (); };
            return ((size + 1) * size) / 2;
        }
        static
       
        size_type lower_element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1660 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1661 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            if (! (i >= j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1662 << ":" << std::endl; std::cerr << "i >= j" << std::endl; bad_index ().raise (); };



            return i - j + (j * (2 * (std::max) (size_i, size_j) - j + 1)) / 2;
        }
        static
       
        size_type upper_element (size_type i, size_type size_i, size_type j, size_type size_j) {
            if (! (i < size_i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1671 << ":" << std::endl; std::cerr << "i < size_i" << std::endl; bad_index ().raise (); };
            if (! (j < size_j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1672 << ":" << std::endl; std::cerr << "j < size_j" << std::endl; bad_index ().raise (); };
            if (! (i <= j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1673 << ":" << std::endl; std::cerr << "i <= j" << std::endl; bad_index ().raise (); };



            return i + ((j + 1) * j) / 2;
        }


        static
       
        size_type index_M (size_type , size_type index2) {
            return index2;
        }
        static
       
        size_type index_m (size_type index1, size_type ) {
            return index1;
        }
        static
       
        size_type size_M (size_type , size_type size_j) {
            return size_j;
        }
        static
       
        size_type size_m (size_type size_i, size_type ) {
            return size_i;
        }
    };


    template <class Z>
    struct basic_full {
        typedef Z size_type;

        template<class L>
        static
       
        size_type packed_size (L, size_type size_i, size_type size_j) {
            return L::storage_size (size_i, size_j);
        }

        static
       
        bool zero (size_type , size_type ) {
            return false;
        }
        static
       
        bool one (size_type , size_type ) {
            return false;
        }
        static
       
        bool other (size_type , size_type ) {
            return true;
        }

        static
       
        size_type restrict1 (size_type i, size_type j) {
            return i;
        }
        static
       
        size_type restrict2 (size_type i, size_type j) {
            return j;
        }
        static
       
        size_type mutable_restrict1 (size_type i, size_type j) {
            return i;
        }
        static
       
        size_type mutable_restrict2 (size_type i, size_type j) {
            return j;
        }
    };

    namespace detail {
        template < class L >
        struct transposed_structure {
            typedef typename L::size_type size_type;

            template<class LAYOUT>
            static
           
            size_type packed_size (LAYOUT l, size_type size_i, size_type size_j) {
                return L::packed_size(l, size_j, size_i);
            }

            static
           
            bool zero (size_type i, size_type j) {
                return L::zero(j, i);
            }
            static
           
            bool one (size_type i, size_type j) {
                return L::one(j, i);
            }
            static
           
            bool other (size_type i, size_type j) {
                return L::other(j, i);
            }
            template<class LAYOUT>
            static
           
            size_type element (LAYOUT l, size_type i, size_type size_i, size_type j, size_type size_j) {
                return L::element(typename LAYOUT::transposed_layout(), j, size_j, i, size_i);
            }

            static
           
            size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
                return L::restrict2(j, i, size2, size1);
            }
            static
           
            size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
                return L::restrict1(j, i, size2, size1);
            }
            static
           
            size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
                return L::mutable_restrict2(j, i, size2, size1);
            }
            static
           
            size_type mutable_restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
                return L::mutable_restrict1(j, i, size2, size1);
            }

            static
           
            size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
                return L::global_restrict2(index2, size2, index1, size1);
            }
            static
           
            size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
                return L::global_restrict1(index2, size2, index1, size1);
            }
            static
           
            size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
                return L::global_mutable_restrict2(index2, size2, index1, size1);
            }
            static
           
            size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
                return L::global_mutable_restrict1(index2, size2, index1, size1);
            }
        };
    }

    template <class Z>
    struct basic_lower {
        typedef Z size_type;
        typedef lower_tag triangular_type;

        template<class L>
        static
       
        size_type packed_size (L, size_type size_i, size_type size_j) {
            return L::triangular_size (size_i, size_j);
        }

        static
       
        bool zero (size_type i, size_type j) {
            return j > i;
        }
        static
       
        bool one (size_type , size_type ) {
            return false;
        }
        static
       
        bool other (size_type i, size_type j) {
            return j <= i;
        }
        template<class L>
        static
       
        size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j) {
            return L::lower_element (i, size_i, j, size_j);
        }


        static
       
        size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
            return (std::max)(j, (std::min) (size1, i));
        }

        static
       
        size_type restrict2 (size_type i, size_type j, size_type , size_type ) {
            return (std::max)(size_type(0), (std::min) (i+1, j));
        }

        static
       
        size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
            return (std::max)(j, (std::min) (size1, i));
        }

        static
       
        size_type mutable_restrict2 (size_type i, size_type j, size_type , size_type ) {
            return (std::max)(size_type(0), (std::min) (i+1, j));
        }


        static
       
        size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return (std::max)(size_type(0), (std::min)(size1, index1) );
        }

        static
       
        size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return (std::max)(size_type(0), (std::min)(size2, index2) );
        }


        static
       
        size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return (std::max)(size_type(0), (std::min)(size1, index1) );
        }

        static
       
        size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return (std::max)(size_type(0), (std::min)(size2, index2) );
        }
    };


    template <class Z>
    struct basic_unit_lower : public basic_lower<Z> {
        typedef Z size_type;
        typedef unit_lower_tag triangular_type;

        template<class L>
        static
       
        size_type packed_size (L, size_type size_i, size_type size_j) {

            if (! (size_i != 0 && size_j != 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1928 << ":" << std::endl; std::cerr << "size_i != 0 && size_j != 0" << std::endl; bad_index ().raise (); };
            return L::triangular_size (size_i - 1, size_j - 1);
        }

        static
       
        bool one (size_type i, size_type j) {
            return j == i;
        }
        static
       
        bool other (size_type i, size_type j) {
            return j < i;
        }
        template<class L>
        static
       
        size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j) {

            if (! (size_i != 0 && size_j != 0 && i != 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1947 << ":" << std::endl; std::cerr << "size_i != 0 && size_j != 0 && i != 0" << std::endl; bad_index ().raise (); };
            return L::lower_element (i-1, size_i - 1, j, size_j - 1);
        }

        static
       
        size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
            return (std::max)(j+1, (std::min) (size1, i));
        }
        static
       
        size_type mutable_restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
            return (std::max)(size_type(0), (std::min) (i, j));
        }


        static
       
        size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return (std::max)(size_type(1), (std::min)(size1, index1) );
        }

        static
       
        size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
            if (! (size2 >= 1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1972 << ":" << std::endl; std::cerr << "size2 >= 1" << std::endl; external_logic().raise (); };
            return (std::max)(size_type(0), (std::min)(size2-1, index2) );
        }
    };


    template <class Z>
    struct basic_strict_lower : public basic_unit_lower<Z> {
        typedef Z size_type;
        typedef strict_lower_tag triangular_type;

        template<class L>
        static
       
        size_type packed_size (L, size_type size_i, size_type size_j) {

            if (! (size_i != 0 && size_j != 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 1988 << ":" << std::endl; std::cerr << "size_i != 0 && size_j != 0" << std::endl; bad_index ().raise (); };
            return L::triangular_size (size_i - 1, size_j - 1);
        }

        static
       
        bool zero (size_type i, size_type j) {
            return j >= i;
        }
        static
       
        bool one (size_type , size_type ) {
            return false;
        }
        static
       
        bool other (size_type i, size_type j) {
            return j < i;
        }
        template<class L>
        static
       
        size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j) {

            if (! (size_i != 0 && size_j != 0 && i != 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/functional.hpp" << " at line " << 2012 << ":" << std::endl; std::cerr << "size_i != 0 && size_j != 0 && i != 0" << std::endl; bad_index ().raise (); };
            return L::lower_element (i-1, size_i - 1, j, size_j - 1);
        }

        static
       
        size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
            return mutable_restrict1(i, j, size1, size2);
        }
        static
       
        size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
            return mutable_restrict2(i, j, size1, size2);
        }


        static
       
        size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return global_mutable_restrict1(index1, size1, index2, size2);
        }

        static
       
        size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
            return global_mutable_restrict2(index1, size1, index2, size2);
        }
    };


    template <class Z>
    struct basic_upper : public detail::transposed_structure<basic_lower<Z> >
    {
        typedef upper_tag triangular_type;
    };

    template <class Z>
    struct basic_unit_upper : public detail::transposed_structure<basic_unit_lower<Z> >
    {
        typedef unit_upper_tag triangular_type;
    };

    template <class Z>
    struct basic_strict_upper : public detail::transposed_structure<basic_strict_lower<Z> >
    {
        typedef strict_upper_tag triangular_type;
    };


}}}
# 18 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp" 2





namespace boost { namespace numeric { namespace ublas {



    template<class E>
    class ublas_expression {
    public:
        typedef E expression_type;






    protected:
        ublas_expression () {}
        ~ublas_expression () {}
    private:
        const ublas_expression& operator= (const ublas_expression &);
    };







    template<class E>
    class scalar_expression:
        public ublas_expression<E> {
    public:
        typedef E expression_type;
        typedef scalar_tag type_category;

       
        const expression_type &operator () () const {
            return *static_cast<const expression_type *> (this);
        }
       
        expression_type &operator () () {
            return *static_cast<expression_type *> (this);
        }
    };

    template<class T>
    class scalar_reference:
        public scalar_expression<scalar_reference<T> > {

        typedef scalar_reference<T> self_type;
    public:
        typedef T value_type;
        typedef const value_type &const_reference;
        typedef typename boost::mpl::if_<boost::is_const<T>,
                                          const_reference,
                                          value_type &>::type reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;


       
        explicit scalar_reference (reference t):
            t_ (t) {}


       
        operator value_type () const {
            return t_;
        }


       
        scalar_reference &operator = (const scalar_reference &s) {
            t_ = s.t_;
            return *this;
        }
        template<class AE>
       
        scalar_reference &operator = (const scalar_expression<AE> &ae) {
            t_ = ae;
            return *this;
        }


       
        bool same_closure (const scalar_reference &sr) const {
            return &t_ == &sr.t_;
        }

    private:
        reference t_;
    };

    template<class T>
    class scalar_value:
        public scalar_expression<scalar_value<T> > {

        typedef scalar_value<T> self_type;
    public:
        typedef T value_type;
        typedef const value_type &const_reference;
        typedef typename boost::mpl::if_<boost::is_const<T>,
                                          const_reference,
                                          value_type &>::type reference;
        typedef const scalar_reference<const self_type> const_closure_type;
        typedef scalar_reference<self_type> closure_type;


       
        scalar_value ():
            t_ () {}
       
        scalar_value (const value_type &t):
            t_ (t) {}

       
        operator value_type () const {
            return t_;
        }


       
        scalar_value &operator = (const scalar_value &s) {
            t_ = s.t_;
            return *this;
        }
        template<class AE>
       
        scalar_value &operator = (const scalar_expression<AE> &ae) {
            t_ = ae;
            return *this;
        }


       
        bool same_closure (const scalar_value &sv) const {
            return this == &sv;
        }

    private:
        value_type t_;
    };







    template<class E>
    class vector_expression:
        public ublas_expression<E> {
    public:
        static const unsigned complexity = 0;
        typedef E expression_type;
        typedef vector_tag type_category;




       
        const expression_type &operator () () const {
            return *static_cast<const expression_type *> (this);
        }
       
        expression_type &operator () () {
            return *static_cast<expression_type *> (this);
        }
# 256 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp"
    };






    template<class C>
    class vector_container:
        public vector_expression<C> {
    public:
        static const unsigned complexity = 0;
        typedef C container_type;
        typedef vector_tag type_category;

       
        const container_type &operator () () const {
            return *static_cast<const container_type *> (this);
        }
       
        container_type &operator () () {
            return *static_cast<container_type *> (this);
        }




    };







    template<class E>
    class matrix_expression:
        public ublas_expression<E> {
    private:
        typedef matrix_expression<E> self_type;
    public:
        static const unsigned complexity = 0;
        typedef E expression_type;
        typedef matrix_tag type_category;




       
        const expression_type &operator () () const {
            return *static_cast<const expression_type *> (this);
        }
       
        expression_type &operator () () {
            return *static_cast<expression_type *> (this);
        }
# 412 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp"
    };
# 466 "/usr/include/boost-1_41/boost/numeric/ublas/expression_types.hpp"
    template<class C>
    class matrix_container:
        public matrix_expression<C> {
    public:
        static const unsigned complexity = 0;
        typedef C container_type;
        typedef matrix_tag type_category;

       
        const container_type &operator () () const {
            return *static_cast<const container_type *> (this);
        }
       
        container_type &operator () () {
            return *static_cast<container_type *> (this);
        }




    };

}}}
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" 2







namespace boost { namespace numeric { namespace ublas {

    template<class E>
    class vector_reference:
        public vector_expression<vector_reference<E> > {

        typedef vector_reference<E> self_type;
    public:



        typedef typename E::size_type size_type;
        typedef typename E::difference_type difference_type;
        typedef typename E::value_type value_type;
        typedef typename E::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<E>,
                                          typename E::const_reference,
                                          typename E::reference>::type reference;
        typedef E referred_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename E::storage_category storage_category;


       
        explicit vector_reference (referred_type &e):
            e_ (e) {}


       
        size_type size () const {
            return expression ().size ();
        }

    public:

       
        const referred_type &expression () const {
            return e_;
        }
       
        referred_type &expression () {
            return e_;
        }

    public:


       
        const_reference operator () (size_type i) const {
            return expression () (i);
        }
       
        reference operator () (size_type i) {
            return expression () (i);
        }

       
        const_reference operator [] (size_type i) const {
            return expression () [i];
        }
       
        reference operator [] (size_type i) {
            return expression () [i];
        }
# 102 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp"
       
        vector_reference &operator = (const vector_reference &v) {
            expression ().operator = (v);
            return *this;
        }
        template<class AE>
       
        vector_reference &operator = (const vector_expression<AE> &ae) {
            expression ().operator = (ae);
            return *this;
        }
        template<class AE>
       
        vector_reference &assign (const vector_expression<AE> &ae) {
            expression ().assign (ae);
            return *this;
        }
        template<class AE>
       
        vector_reference &operator += (const vector_expression<AE> &ae) {
            expression ().operator += (ae);
            return *this;
        }
        template<class AE>
       
        vector_reference &plus_assign (const vector_expression<AE> &ae) {
            expression ().plus_assign (ae);
            return *this;
        }
        template<class AE>
       
        vector_reference &operator -= (const vector_expression<AE> &ae) {
            expression ().operator -= (ae);
            return *this;
        }
        template<class AE>
       
        vector_reference &minus_assign (const vector_expression<AE> &ae) {
            expression ().minus_assign (ae);
            return *this;
        }
        template<class AT>
       
        vector_reference &operator *= (const AT &at) {
            expression ().operator *= (at);
            return *this;
        }
        template<class AT>
       
        vector_reference &operator /= (const AT &at) {
            expression ().operator /= (at);
            return *this;
        }


       
        void swap (vector_reference &v) {
            expression ().swap (v.expression ());
        }


       
        bool same_closure (const vector_reference &vr) const {
            return &(*this).e_ == &vr.e_;
        }


        typedef typename E::const_iterator const_iterator;
        typedef typename boost::mpl::if_<boost::is_const<E>,
                                          typename E::const_iterator,
                                          typename E::iterator>::type iterator;


       
        const_iterator find (size_type i) const {
            return expression ().find (i);
        }
       
        iterator find (size_type i) {
            return expression ().find (i);
        }



       
        const_iterator begin () const {
            return expression ().begin ();
        }
       
        const_iterator end () const {
            return expression ().end ();
        }

       
        iterator begin () {
            return expression ().begin ();
        }
       
        iterator end () {
            return expression ().end ();
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        referred_type &e_;
    };


    template<class E, class F>
    class vector_unary:
        public vector_expression<vector_unary<E, F> > {

        typedef F functor_type;
        typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<typename E::value_type> >,
                                          E,
                                          const E>::type expression_type;
        typedef typename boost::mpl::if_<boost::is_const<expression_type>,
                                          typename E::const_closure_type,
                                          typename E::closure_type>::type expression_closure_type;
        typedef vector_unary<E, F> self_type;
    public:



        typedef typename E::size_type size_type;
        typedef typename E::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<value_type> >,
                                          typename E::reference,
                                          value_type>::type reference;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef unknown_storage_tag storage_category;


       

        explicit vector_unary (expression_type &e):
            e_ (e) {}


       
        size_type size () const {
            return e_.size ();
        }

    public:

       
        const expression_closure_type &expression () const {
            return e_;
        }

    public:

       
        const_reference operator () (size_type i) const {
            return functor_type::apply (e_ (i));
        }
       
        reference operator () (size_type i) {
            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<functor_type, scalar_identity<value_type > >::value)) == 0 ? false : true) >)> boost_static_assert_typedef_284;
            return e_ (i);
        }

       
        const_reference operator [] (size_type i) const {
            return functor_type::apply (e_ [i]);
        }
       
        reference operator [] (size_type i) {
            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<functor_type, scalar_identity<value_type > >::value)) == 0 ? false : true) >)> boost_static_assert_typedef_294;
            return e_ [i];
        }


       
        bool same_closure (const vector_unary &vu) const {
            return (*this).expression ().same_closure (vu.expression ());
        }


    private:
        typedef typename E::const_iterator const_subiterator_type;
        typedef const value_type *const_pointer;

    public:




        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type i) const {




            return const_iterator (*this, e_.find (i));

        }





        class const_iterator:
            public container_const_reference<vector_unary>,
            public iterator_base_traits<typename E::const_iterator::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename E::const_iterator::iterator_category iterator_category;
            typedef typename vector_unary::difference_type difference_type;
            typedef typename vector_unary::value_type value_type;
            typedef typename vector_unary::const_reference reference;
            typedef typename vector_unary::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &vu, const const_subiterator_type &it):
                container_const_reference<self_type> (vu), it_ (it) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 375 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_.index ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 406 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 411 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression_closure_type e_;
    };

    template<class E, class F>
    struct vector_unary_traits {
        typedef vector_unary<E, F> expression_type;


        typedef expression_type result_type;



    };


    template<class E>
   
    typename vector_unary_traits<E, scalar_negate<typename E::value_type> >::result_type
    operator - (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_negate<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type
    conj (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_unary_traits<E, scalar_real<typename E::value_type> >::result_type
    real (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_real<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_unary_traits<E, scalar_imag<typename E::value_type> >::result_type
    imag (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_imag<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_unary_traits<const E, scalar_identity<typename E::value_type> >::result_type
    trans (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<const E, scalar_identity<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }
    template<class E>
   
    typename vector_unary_traits<E, scalar_identity<typename E::value_type> >::result_type
    trans (vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_identity<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type
    herm (const vector_expression<E> &e) {
        typedef typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E1, class E2, class F>
    class vector_binary:
        public vector_expression<vector_binary<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
        typedef vector_binary<E1, E2, F> self_type;
    public:



        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        vector_binary (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size () const {
            return same_impl_ex ((e1_.size ()), (e2_.size ()), "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp", 548);
        }

    private:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:

       
        const_reference operator () (size_type i) const {
            return functor_type::apply (e1_ (i), e2_ (i));
        }

       
        const_reference operator [] (size_type i) const {
            return functor_type::apply (e1_ [i], e2_ [i]);
        }


       
        bool same_closure (const vector_binary &vb) const {
            return (*this).expression1 ().same_closure (vb.expression1 ()) &&
                   (*this).expression2 ().same_closure (vb.expression2 ());
        }


    private:
        typedef typename E1::const_iterator const_subiterator1_type;
        typedef typename E2::const_iterator const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:






        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type i) const {
            const_subiterator1_type it1 (e1_.find (i));
            const_subiterator1_type it1_end (e1_.find (size ()));
            const_subiterator2_type it2 (e2_.find (i));
            const_subiterator2_type it2_end (e2_.find (size ()));
            i = (std::min) (it1 != it1_end ? it1.index () : size (),
                          it2 != it2_end ? it2.index () : size ());



            return const_iterator (*this, i, it1, it1_end, it2, it2_end);

        }





        class const_iterator:
            public container_const_reference<vector_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                                          typename E2::const_iterator::iterator_category>::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                      typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
            typedef typename vector_binary::difference_type difference_type;
            typedef typename vector_binary::value_type value_type;
            typedef typename vector_binary::const_reference reference;
            typedef typename vector_binary::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), i_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
           
            const_iterator (const self_type &vb, size_type i,
                            const const_subiterator1_type &it1, const const_subiterator1_type &it1_end,
                            const const_subiterator2_type &it2, const const_subiterator2_type &it2_end):
                container_const_reference<self_type> (vb), i_ (i), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}

        private:

           
            void increment (dense_random_access_iterator_tag) {
                ++ i_; ++ it1_; ++ it2_;
            }
           
            void decrement (dense_random_access_iterator_tag) {
                -- i_; -- it1_; -- it2_;
            }
           
            void increment (dense_random_access_iterator_tag, difference_type n) {
                i_ += n; it1_ += n; it2_ += n;
            }
           
            void decrement (dense_random_access_iterator_tag, difference_type n) {
                i_ -= n; it1_ -= n; it2_ -= n;
            }
           
            value_type dereference (dense_random_access_iterator_tag) const {
                return functor_type::apply (*it1_, *it2_);
            }


           
            void increment (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (it1_.index () <= i_)
                        ++ it1_;
                if (it2_ != it2_end_)
                    if (it2_.index () <= i_)
                        ++ it2_;
                ++ i_;
            }
           
            void decrement (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (i_ <= it1_.index ())
                        -- it1_;
                if (it2_ != it2_end_)
                    if (i_ <= it2_.index ())
                        -- it2_;
                -- i_;
            }
           
            void increment (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (packed_random_access_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_)
                    if (it1_.index () == i_)
                        t1 = *it1_;
                value_type t2 = value_type ();
                if (it2_ != it2_end_)
                    if (it2_.index () == i_)
                        t2 = *it2_;
                return functor_type::apply (t1, t2);
            }


           
            void increment (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size ();
                if (it1_ != it1_end_) {
                    if (it1_.index () <= i_)
                        ++ it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index ();
                }
                size_type index2 = (*this) ().size ();
                if (it2_ != it2_end_) {
                    if (it2_.index () <= i_)
                        ++ it2_;
                    if (it2_ != it2_end_)
                        index2 = it2_.index ();
                }
                i_ = (std::min) (index1, index2);
            }
           
            void decrement (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size ();
                if (it1_ != it1_end_) {
                    if (i_ <= it1_.index ())
                        -- it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index ();
                }
                size_type index2 = (*this) ().size ();
                if (it2_ != it2_end_) {
                    if (i_ <= it2_.index ())
                        -- it2_;
                    if (it2_ != it2_end_)
                        index2 = it2_.index ();
                }
                i_ = (std::max) (index1, index2);
            }
           
            void increment (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (sparse_bidirectional_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_)
                    if (it1_.index () == i_)
                        t1 = *it1_;
                value_type t2 = value_type ();
                if (it2_ != it2_end_)
                    if (it2_.index () == i_)
                        t2 = *it2_;
                return functor_type::apply (t1, t2);
            }

        public:

           
            const_iterator &operator ++ () {
                increment (iterator_category ());
                return *this;
            }
           
            const_iterator &operator -- () {
                decrement (iterator_category ());
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                increment (iterator_category (), n);
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                decrement (iterator_category (), n);
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 816 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return index () - it.index ();
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return i_;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                i_ = it.i_;
                it1_ = it.it1_;
                it1_end_ = it.it1_end_;
                it2_ = it.it2_;
                it2_end_ = it.it2_end_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 851 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return index () == it.index ();
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 856 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return index () < it.index ();
            }

        private:
            size_type i_;
            const_subiterator1_type it1_;
            const_subiterator1_type it1_end_;
            const_subiterator2_type it2_;
            const_subiterator2_type it2_end_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct vector_binary_traits {
        typedef vector_binary<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E1, class E2>
   
    typename vector_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
                                                      typename E2::value_type> >::result_type
    operator + (const vector_expression<E1> &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
                                                                              typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename vector_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
                                                       typename E2::value_type> >::result_type
    operator - (const vector_expression<E1> &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
                                                                               typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename vector_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
                                                            typename E2::value_type> >::result_type
    element_prod (const vector_expression<E1> &e1,
                  const vector_expression<E2> &e2) {
        typedef typename vector_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
                                                                                    typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                         typename E2::value_type> >::result_type
    element_div (const vector_expression<E1> &e1,
                 const vector_expression<E2> &e2) {
        typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                                                 typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2, class F>
    class vector_binary_scalar1:
        public vector_expression<vector_binary_scalar1<E1, E2, F> > {

        typedef F functor_type;
        typedef E1 expression1_type;
        typedef E2 expression2_type;
    public:
        typedef const E1& expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef vector_binary_scalar1<E1, E2, F> self_type;
    public:



        typedef typename E2::size_type size_type;
        typedef typename E2::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        vector_binary_scalar1 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size () const {
            return e2_.size ();
        }

    public:

       
        const_reference operator () (size_type i) const {
            return functor_type::apply (e1_, e2_ (i));
        }

       
        const_reference operator [] (size_type i) const {
            return functor_type::apply (e1_, e2_ [i]);
        }


       
        bool same_closure (const vector_binary_scalar1 &vbs1) const {
            return &e1_ == &(vbs1.e1_) &&
                   (*this).e2_.same_closure (vbs1.e2_);
        }


    private:
        typedef expression1_type const_subiterator1_type;
        typedef typename expression2_type::const_iterator const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:




        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type i) const {




            return const_iterator (*this, const_subiterator1_type (e1_), e2_.find (i));

        }





        class const_iterator:
            public container_const_reference<vector_binary_scalar1>,
            public iterator_base_traits<typename E2::const_iterator::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename E2::const_iterator::iterator_category iterator_category;
            typedef typename vector_binary_scalar1::difference_type difference_type;
            typedef typename vector_binary_scalar1::value_type value_type;
            typedef typename vector_binary_scalar1::const_reference reference;
            typedef typename vector_binary_scalar1::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (vbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1081 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it2_.index ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1115 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1122 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct vector_binary_scalar1_traits {
        typedef vector_binary_scalar1<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class T1, class E2>
   
    typename enable_if< is_convertible<T1, typename E2::value_type >,
    typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
    >::type
    operator * (const T1 &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1, e2 ());
    }


    template<class E1, class E2, class F>
    class vector_binary_scalar2:
        public vector_expression<vector_binary_scalar2<E1, E2, F> > {

        typedef F functor_type;
        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef const E2& expression2_closure_type;
        typedef vector_binary_scalar2<E1, E2, F> self_type;
    public:



        typedef typename E1::size_type size_type;
        typedef typename E1::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        vector_binary_scalar2 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size () const {
            return e1_.size ();
        }

    public:

       
        const_reference operator () (size_type i) const {
            return functor_type::apply (e1_ (i), e2_);
        }

       
        const_reference operator [] (size_type i) const {
            return functor_type::apply (e1_ [i], e2_);
        }


       
        bool same_closure (const vector_binary_scalar2 &vbs2) const {
            return (*this).e1_.same_closure (vbs2.e1_) &&
                   &e2_ == &(vbs2.e2_);
        }


    private:
        typedef typename expression1_type::const_iterator const_subiterator1_type;
        typedef expression2_type const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:




        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type i) const {




            return const_iterator (*this, e1_.find (i), const_subiterator2_type (e2_));

        }





        class const_iterator:
            public container_const_reference<vector_binary_scalar2>,
            public iterator_base_traits<typename E1::const_iterator::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename E1::const_iterator::iterator_category iterator_category;
            typedef typename vector_binary_scalar2::difference_type difference_type;
            typedef typename vector_binary_scalar2::value_type value_type;
            typedef typename vector_binary_scalar2::const_reference reference;
            typedef typename vector_binary_scalar2::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (vbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1308 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it1_, it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it1_.index ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1342 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1349 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ < it.it1_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct vector_binary_scalar2_traits {
        typedef vector_binary_scalar2<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E1, class T2>
   
    typename enable_if< is_convertible<T2, typename E1::value_type >,
    typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
    >::type
    operator * (const vector_expression<E1> &e1,
                const T2 &e2) {
        typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
        return expression_type (e1 (), e2);
    }


    template<class E1, class T2>
   
    typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
    operator / (const vector_expression<E1> &e1,
                const T2 &e2) {
        typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
        return expression_type (e1 (), e2);
    }


    template<class E, class F>
    class vector_scalar_unary:
        public scalar_expression<vector_scalar_unary<E, F> > {

        typedef E expression_type;
        typedef F functor_type;
        typedef typename E::const_closure_type expression_closure_type;
        typedef typename E::const_iterator::iterator_category iterator_category;
        typedef vector_scalar_unary<E, F> self_type;
    public:
        typedef typename F::result_type value_type;
        typedef typename E::difference_type difference_type;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        explicit vector_scalar_unary (const expression_type &e):
            e_ (e) {}

    private:

       
        const expression_closure_type &expression () const {
            return e_;
        }

    public:
       
        operator value_type () const {
            return evaluate (iterator_category ());
        }

    private:

       
        value_type evaluate (dense_random_access_iterator_tag) const {

            return functor_type::apply (e_);
# 1470 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp"
        }


       
        value_type evaluate (packed_random_access_iterator_tag) const {
            return functor_type::apply (e_.begin (), e_.end ());
        }


       
        value_type evaluate (sparse_bidirectional_iterator_tag) const {
            return functor_type::apply (e_.begin (), e_.end ());
        }

    private:
        expression_closure_type e_;
    };

    template<class E, class F>
    struct vector_scalar_unary_traits {
        typedef vector_scalar_unary<E, F> expression_type;





         typedef typename F::result_type result_type;

    };


    template<class E>
   
    typename vector_scalar_unary_traits<E, vector_sum<E> >::result_type
    sum (const vector_expression<E> &e) {
        typedef typename vector_scalar_unary_traits<E, vector_sum<E> >::expression_type expression_type;
        return expression_type (e ());
    }



    template<class E>
   
    typename vector_scalar_unary_traits<E, vector_norm_1<E> >::result_type
    norm_1 (const vector_expression<E> &e) {
        typedef typename vector_scalar_unary_traits<E, vector_norm_1<E> >::expression_type expression_type;
        return expression_type (e ());
    }



    template<class E>
   
    typename vector_scalar_unary_traits<E, vector_norm_2<E> >::result_type
    norm_2 (const vector_expression<E> &e) {
        typedef typename vector_scalar_unary_traits<E, vector_norm_2<E> >::expression_type expression_type;
        return expression_type (e ());
    }



    template<class E>
   
    typename vector_scalar_unary_traits<E, vector_norm_inf<E> >::result_type
    norm_inf (const vector_expression<E> &e) {
        typedef typename vector_scalar_unary_traits<E, vector_norm_inf<E> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename vector_scalar_unary_traits<E, vector_index_norm_inf<E> >::result_type
    index_norm_inf (const vector_expression<E> &e) {
        typedef typename vector_scalar_unary_traits<E, vector_index_norm_inf<E> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E1, class E2, class F>
    class vector_scalar_binary:
        public scalar_expression<vector_scalar_binary<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
        typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                  typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
        typedef vector_scalar_binary<E1, E2, F> self_type;
    public:
        static const unsigned complexity = 1;
        typedef typename F::result_type value_type;
        typedef typename E1::difference_type difference_type;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        vector_scalar_binary (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}

    private:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:
       
        operator value_type () const {
            return evaluate (iterator_category ());
        }

    private:

       
        value_type evaluate (dense_random_access_iterator_tag) const {
            if (! (e1_.size () == e2_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1594 << ":" << std::endl; std::cerr << "e1_.size () == e2_.size ()" << std::endl; external_logic().raise (); };

            return functor_type::apply (e1_, e2_);
# 1607 "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp"
        }


       
        value_type evaluate (packed_random_access_iterator_tag) const {
            if (! (e1_.size () == e2_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1612 << ":" << std::endl; std::cerr << "e1_.size () == e2_.size ()" << std::endl; external_logic().raise (); };
            return functor_type::apply (e1_.begin (), e1_.end (), e2_.begin (), e2_.end ());
        }


       
        value_type evaluate (sparse_bidirectional_iterator_tag) const {
            if (! (e1_.size () == e2_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_expression.hpp" << " at line " << 1619 << ":" << std::endl; std::cerr << "e1_.size () == e2_.size ()" << std::endl; external_logic().raise (); };
            return functor_type::apply (e1_.begin (), e1_.end (), e2_.begin (), e2_.end (), sparse_bidirectional_iterator_tag ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct vector_scalar_binary_traits {
        typedef vector_scalar_binary<E1, E2, F> expression_type;





        typedef typename F::result_type result_type;

    };


    template<class E1, class E2>
   
    typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
                                                                   typename promote_traits<typename E1::value_type,
                                                                                           typename E2::value_type>::promote_type> >::result_type
    inner_prod (const vector_expression<E1> &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
                                                                   typename promote_traits<typename E1::value_type,
                                                                                           typename E2::value_type>::promote_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }

    template<class E1, class E2>
   
    typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
                                                                   typename type_traits<typename promote_traits<typename E1::value_type,
                                                                                                                typename E2::value_type>::promote_type>::precision_type> >::result_type
    prec_inner_prod (const vector_expression<E1> &e1,
                     const vector_expression<E2> &e2) {
        typedef typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
                                                                   typename type_traits<typename promote_traits<typename E1::value_type,
                                                                                                                typename E2::value_type>::promote_type>::precision_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }

}}}
# 18 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp"
#define _BOOST_UBLAS_VECTOR_ASSIGN_ 







namespace boost { namespace numeric { namespace ublas {
namespace detail {






    template<class E1, class E2, class S>
   
    bool equals (const vector_expression<E1> &e1, const vector_expression<E2> &e2, S epsilon, S min_norm) {
        return norm_inf (e1 - e2) < epsilon *
               std::max<S> (std::max<S> (norm_inf (e1), norm_inf (e2)), min_norm);
    }

    template<class E1, class E2>
   
    bool expression_type_check (const vector_expression<E1> &e1, const vector_expression<E2> &e2) {
        typedef typename type_traits<typename promote_traits<typename E1::value_type,
                                     typename E2::value_type>::promote_type>::real_type real_type;
        return equals (e1, e2, (type_traits<real_type>::type_sqrt (std::numeric_limits<real_type>::epsilon ())), (type_traits<real_type>::type_sqrt ( (std::numeric_limits<real_type>::min) ())));
    }



    template<class V, class E>

    void make_conformant (V &v, const vector_expression<E> &e) {
        if (! (v.size () == e ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 50 << ":" << std::endl; std::cerr << "v.size () == e ().size ()" << std::endl; bad_size ().raise (); };
        typedef typename V::size_type size_type;
        typedef typename V::difference_type difference_type;
        typedef typename V::value_type value_type;

        std::vector<size_type> index;
        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        typename E::const_iterator ite (e ().begin ());
        typename E::const_iterator ite_end (e ().end ());
        if (it != it_end && ite != ite_end) {
            size_type it_index = it.index (), ite_index = ite.index ();
            while (true) {
                difference_type compare = it_index - ite_index;
                if (compare == 0) {
                    ++ it, ++ ite;
                    if (it != it_end && ite != ite_end) {
                        it_index = it.index ();
                        ite_index = ite.index ();
                    } else
                        break;
                } else if (compare < 0) {
                    increment (it, it_end, - compare);
                    if (it != it_end)
                        it_index = it.index ();
                    else
                        break;
                } else if (compare > 0) {
                    if (*ite != value_type ())
                        index.push_back (ite.index ());
                    ++ ite;
                    if (ite != ite_end)
                        ite_index = ite.index ();
                    else
                        break;
                }
            }
        }

        while (ite != ite_end) {
            if (*ite != value_type ())
                index.push_back (ite.index ());
            ++ ite;
        }
        for (size_type k = 0; k < index.size (); ++ k)
            v (index [k]) = value_type ();
    }

}



    template<template <class T1, class T2> class F, class V, class T>

    void iterating_vector_assign_scalar (V &v, const T &t) {
        typedef F<typename V::iterator::reference, T> functor_type;
        typedef typename V::difference_type difference_type;
        difference_type size (v.size ());
        typename V::iterator it (v.begin ());
        if (! (v.end () - it == size)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 109 << ":" << std::endl; std::cerr << "v.end () - it == size" << std::endl; bad_size ().raise (); };

        while (-- size >= 0)
            functor_type::apply (*it, t), ++ it;



    }

    template<template <class T1, class T2> class F, class V, class T>

    void indexing_vector_assign_scalar (V &v, const T &t) {
        typedef F<typename V::reference, T> functor_type;
        typedef typename V::size_type size_type;
        size_type size (v.size ());

        for (size_type i = 0; i < size; ++ i)
            functor_type::apply (v (i), t);




    }


    template<template <class T1, class T2> class F, class V, class T>

    void vector_assign_scalar (V &v, const T &t, dense_proxy_tag) {

        indexing_vector_assign_scalar<F> (v, t);
# 149 "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp"
    }

    template<template <class T1, class T2> class F, class V, class T>

    void vector_assign_scalar (V &v, const T &t, packed_proxy_tag) {
        typedef F<typename V::iterator::reference, T> functor_type;
        typedef typename V::difference_type difference_type;
        typename V::iterator it (v.begin ());
        difference_type size (v.end () - it);
        while (-- size >= 0)
            functor_type::apply (*it, t), ++ it;
    }

    template<template <class T1, class T2> class F, class V, class T>

    void vector_assign_scalar (V &v, const T &t, sparse_proxy_tag) {
        typedef F<typename V::iterator::reference, T> functor_type;
        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        while (it != it_end)
            functor_type::apply (*it, t), ++ it;
    }


    template<template <class T1, class T2> class F, class V, class T>
   
    void vector_assign_scalar (V &v, const T &t) {
        typedef typename V::storage_category storage_category;
        vector_assign_scalar<F> (v, t, storage_category ());
    }

    template<class SC, bool COMPUTED, class RI>
    struct vector_assign_traits {
        typedef SC storage_category;
    };

    template<bool COMPUTED>
    struct vector_assign_traits<dense_tag, COMPUTED, packed_random_access_iterator_tag> {
        typedef packed_tag storage_category;
    };
    template<>
    struct vector_assign_traits<dense_tag, false, sparse_bidirectional_iterator_tag> {
        typedef sparse_tag storage_category;
    };
    template<>
    struct vector_assign_traits<dense_tag, true, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<bool COMPUTED>
    struct vector_assign_traits<dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<>
    struct vector_assign_traits<dense_proxy_tag, false, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct vector_assign_traits<dense_proxy_tag, true, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct vector_assign_traits<packed_tag, false, sparse_bidirectional_iterator_tag> {
        typedef sparse_tag storage_category;
    };
    template<>
    struct vector_assign_traits<packed_tag, true, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<bool COMPUTED>
    struct vector_assign_traits<packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct vector_assign_traits<sparse_tag, true, dense_random_access_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct vector_assign_traits<sparse_tag, true, packed_random_access_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct vector_assign_traits<sparse_tag, true, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };


    template<template <class T1, class T2> class F, class V, class E>

    void iterating_vector_assign (V &v, const vector_expression<E> &e) {
        typedef F<typename V::iterator::reference, typename E::value_type> functor_type;
        typedef typename V::difference_type difference_type;
        difference_type size (same_impl_ex ((v.size ()), (e ().size ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp", 244));
        typename V::iterator it (v.begin ());
        if (! (v.end () - it == size)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 246 << ":" << std::endl; std::cerr << "v.end () - it == size" << std::endl; bad_size ().raise (); };
        typename E::const_iterator ite (e ().begin ());
        if (! (e ().end () - ite == size)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 248 << ":" << std::endl; std::cerr << "e ().end () - ite == size" << std::endl; bad_size ().raise (); };

        while (-- size >= 0)
            functor_type::apply (*it, *ite), ++ it, ++ ite;



    }

    template<template <class T1, class T2> class F, class V, class E>

    void indexing_vector_assign (V &v, const vector_expression<E> &e) {
        typedef F<typename V::reference, typename E::value_type> functor_type;
        typedef typename V::size_type size_type;
        size_type size (same_impl_ex ((v.size ()), (e ().size ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp", 262));

        for (size_type i = 0; i < size; ++ i)
            functor_type::apply (v (i), e () (i));




    }


    template<template <class T1, class T2> class F, class V, class E>

    void vector_assign (V &v, const vector_expression<E> &e, dense_proxy_tag) {

        indexing_vector_assign<F> (v, e);
# 288 "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp"
    }

    template<template <class T1, class T2> class F, class V, class E>

    void vector_assign (V &v, const vector_expression<E> &e, packed_proxy_tag) {
        if (! (v.size () == e ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 293 << ":" << std::endl; std::cerr << "v.size () == e ().size ()" << std::endl; bad_size ().raise (); };
        typedef F<typename V::iterator::reference, typename E::value_type> functor_type;
        typedef typename V::difference_type difference_type;
        typedef typename V::value_type value_type;

        vector<value_type> cv (v.size ());
        indexing_vector_assign<scalar_assign> (cv, v);
        indexing_vector_assign<F> (cv, e);

        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        typename E::const_iterator ite (e ().begin ());
        typename E::const_iterator ite_end (e ().end ());
        difference_type it_size (it_end - it);
        difference_type ite_size (ite_end - ite);
        if (it_size > 0 && ite_size > 0) {
            difference_type size ((std::min) (difference_type (it.index () - ite.index ()), ite_size));
            if (size > 0) {
                ite += size;
                ite_size -= size;
            }
        }
        if (it_size > 0 && ite_size > 0) {
            difference_type size ((std::min) (difference_type (ite.index () - it.index ()), it_size));
            if (size > 0) {
                it_size -= size;
                if (!functor_type::computed) {
                    while (-- size >= 0)
                        functor_type::apply (*it, value_type ()), ++ it;
                } else {
                    it += size;
                }
            }
        }
        difference_type size ((std::min) (it_size, ite_size));
        it_size -= size;
        ite_size -= size;
        while (-- size >= 0)
            functor_type::apply (*it, *ite), ++ it, ++ ite;
        size = it_size;
        if (!functor_type::computed) {
            while (-- size >= 0)
                functor_type::apply (*it, value_type ()), ++ it;
        } else {
            it += size;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (v, cv))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 342 << ":" << std::endl; std::cerr << "detail::expression_type_check (v, cv)" << std::endl; external_logic ("external logic or bad condition of inputs").raise (); };


    }

    template<template <class T1, class T2> class F, class V, class E>

    void vector_assign (V &v, const vector_expression<E> &e, sparse_tag) {
        if (! (v.size () == e ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 349 << ":" << std::endl; std::cerr << "v.size () == e ().size ()" << std::endl; bad_size ().raise (); };
        typedef F<typename V::iterator::reference, typename E::value_type> functor_type;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!functor_type::computed)) == 0 ? false : true) >)> boost_static_assert_typedef_351;
        typedef typename V::value_type value_type;

        vector<value_type> cv (v.size ());
        indexing_vector_assign<scalar_assign> (cv, v);
        indexing_vector_assign<F> (cv, e);

        v.clear ();
        typename E::const_iterator ite (e ().begin ());
        typename E::const_iterator ite_end (e ().end ());
        while (ite != ite_end) {
            value_type t (*ite);
            if (t != value_type ())
                v.insert_element (ite.index (), t);
            ++ ite;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (v, cv))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 370 << ":" << std::endl; std::cerr << "detail::expression_type_check (v, cv)" << std::endl; external_logic ("external logic or bad condition of inputs").raise (); };


    }

    template<template <class T1, class T2> class F, class V, class E>

    void vector_assign (V &v, const vector_expression<E> &e, sparse_proxy_tag) {
        if (! (v.size () == e ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 377 << ":" << std::endl; std::cerr << "v.size () == e ().size ()" << std::endl; bad_size ().raise (); };
        typedef F<typename V::iterator::reference, typename E::value_type> functor_type;
        typedef typename V::size_type size_type;
        typedef typename V::difference_type difference_type;
        typedef typename V::value_type value_type;
        typedef typename V::reference reference;

        vector<value_type> cv (v.size ());
        indexing_vector_assign<scalar_assign> (cv, v);
        indexing_vector_assign<F> (cv, e);

        detail::make_conformant (v, e);

        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        typename E::const_iterator ite (e ().begin ());
        typename E::const_iterator ite_end (e ().end ());
        if (it != it_end && ite != ite_end) {
            size_type it_index = it.index (), ite_index = ite.index ();
            while (true) {
                difference_type compare = it_index - ite_index;
                if (compare == 0) {
                    functor_type::apply (*it, *ite);
                    ++ it, ++ ite;
                    if (it != it_end && ite != ite_end) {
                        it_index = it.index ();
                        ite_index = ite.index ();
                    } else
                        break;
                } else if (compare < 0) {
                    if (!functor_type::computed) {
                        functor_type::apply (*it, value_type ());
                        ++ it;
                    } else
                        increment (it, it_end, - compare);
                    if (it != it_end)
                        it_index = it.index ();
                    else
                        break;
                } else if (compare > 0) {
                    increment (ite, ite_end, compare);
                    if (ite != ite_end)
                        ite_index = ite.index ();
                    else
                        break;
                }
            }
        }

        if (!functor_type::computed) {
            while (it != it_end) {
                functor_type::apply (*it, value_type ());
                ++ it;
            }
        } else {
            it = it_end;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (v, cv))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 437 << ":" << std::endl; std::cerr << "detail::expression_type_check (v, cv)" << std::endl; external_logic ("external logic or bad condition of inputs").raise (); };


    }


    template<template <class T1, class T2> class F, class V, class E>
   
    void vector_assign (V &v, const vector_expression<E> &e) {
        typedef typename vector_assign_traits<typename V::storage_category,
                                              F<typename V::reference, typename E::value_type>::computed,
                                              typename E::const_iterator::iterator_category>::storage_category storage_category;
        vector_assign<F> (v, e, storage_category ());
    }

    template<class SC, class RI>
    struct vector_swap_traits {
        typedef SC storage_category;
    };

    template<>
    struct vector_swap_traits<dense_proxy_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct vector_swap_traits<packed_proxy_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };


    template<template <class T1, class T2> class F, class V, class E>

    void vector_swap (V &v, vector_expression<E> &e, dense_proxy_tag) {
        typedef F<typename V::iterator::reference, typename E::iterator::reference> functor_type;
        typedef typename V::difference_type difference_type;
        difference_type size (same_impl_ex ((v.size ()), (e ().size ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp", 472));
        typename V::iterator it (v.begin ());
        typename E::iterator ite (e ().begin ());
        while (-- size >= 0)
            functor_type::apply (*it, *ite), ++ it, ++ ite;
    }

    template<template <class T1, class T2> class F, class V, class E>

    void vector_swap (V &v, vector_expression<E> &e, packed_proxy_tag) {
        typedef F<typename V::iterator::reference, typename E::iterator::reference> functor_type;
        typedef typename V::difference_type difference_type;
        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        typename E::iterator ite (e ().begin ());
        typename E::iterator ite_end (e ().end ());
        difference_type it_size (it_end - it);
        difference_type ite_size (ite_end - ite);
        if (it_size > 0 && ite_size > 0) {
            difference_type size ((std::min) (difference_type (it.index () - ite.index ()), ite_size));
            if (size > 0) {
                ite += size;
                ite_size -= size;
            }
        }
        if (it_size > 0 && ite_size > 0) {
            difference_type size ((std::min) (difference_type (ite.index () - it.index ()), it_size));
            if (size > 0)
                it_size -= size;
        }
        difference_type size ((std::min) (it_size, ite_size));
        it_size -= size;
        ite_size -= size;
        while (-- size >= 0)
            functor_type::apply (*it, *ite), ++ it, ++ ite;
    }

    template<template <class T1, class T2> class F, class V, class E>

    void vector_swap (V &v, vector_expression<E> &e, sparse_proxy_tag) {
        if (! (v.size () == e ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/vector_assign.hpp" << " at line " << 512 << ":" << std::endl; std::cerr << "v.size () == e ().size ()" << std::endl; bad_size ().raise (); };
        typedef F<typename V::iterator::reference, typename E::iterator::reference> functor_type;
        typedef typename V::size_type size_type;
        typedef typename V::difference_type difference_type;
        typedef typename V::value_type value_type;

        detail::make_conformant (v, e);

        detail::make_conformant (e (), v);

        typename V::iterator it (v.begin ());
        typename V::iterator it_end (v.end ());
        typename E::iterator ite (e ().begin ());
        typename E::iterator ite_end (e ().end ());
        if (it != it_end && ite != ite_end) {
            size_type it_index = it.index (), ite_index = ite.index ();
            while (true) {
                difference_type compare = it_index - ite_index;
                if (compare == 0) {
                    functor_type::apply (*it, *ite);
                    ++ it, ++ ite;
                    if (it != it_end && ite != ite_end) {
                        it_index = it.index ();
                        ite_index = ite.index ();
                    } else
                        break;
                } else if (compare < 0) {
                    increment (it, it_end, - compare);
                    if (it != it_end)
                        it_index = it.index ();
                    else
                        break;
                } else if (compare > 0) {
                    increment (ite, ite_end, compare);
                    if (ite != ite_end)
                        ite_index = ite.index ();
                    else
                        break;
                }
            }
        }


        increment (ite, ite_end);
        increment (it, it_end);

    }


    template<template <class T1, class T2> class F, class V, class E>
   
    void vector_swap (V &v, vector_expression<E> &e) {
        typedef typename vector_swap_traits<typename V::storage_category,
                                            typename E::const_iterator::iterator_category>::storage_category storage_category;
        vector_swap<F> (v, e, storage_category ());
    }

}}}
# 19 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" 2





namespace boost { namespace numeric { namespace ublas {


    template<class T, class A>
    class vector:
        public vector_container<vector<T, A> > {

        typedef vector<T, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef typename type_traits<T>::const_reference const_reference;
        typedef T &reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef A array_type;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef self_type vector_temporary_type;
        typedef dense_tag storage_category;


       
        vector ():
            vector_container<self_type> (),
            data_ () {}
        explicit
        vector (size_type size):
            vector_container<self_type> (),
            data_ (size) {
        }
       
        vector (size_type size, const array_type &data):
            vector_container<self_type> (),
            data_ (data) {}
       
        vector (size_type size, const value_type &init):
            vector_container<self_type> (),
            data_ (size, init) {}
       
        vector (const vector &v):
            vector_container<self_type> (),
            data_ (v.data_) {}
        template<class AE>
       
        vector (const vector_expression<AE> &ae):
            vector_container<self_type> (),
            data_ (ae ().size ()) {
            vector_assign<scalar_assign> (*this, ae);
        }


       
        size_type max_size () const {
            return data_.max_size ();
        }

       
        bool empty () const {
            return data_.size () == 0;
        }

       
        size_type size () const {
            return data_.size ();
        }


       
        const array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


       
        void resize (size_type size, bool preserve = true) {
            if (preserve)
                data ().resize (size, typename A::value_type ());
            else
                data ().resize (size);
        }


       
        pointer find_element (size_type i) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
        }
       
        const_pointer find_element (size_type i) const {
            return & (data () [i]);
        }


       
        const_reference operator () (size_type i) const {
            return data () [i];
        }
       
        reference operator () (size_type i) {
            return data () [i];
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        reference insert_element (size_type i, const_reference t) {
            return (data () [i] = t);
        }
       
        void erase_element (size_type i) {
            data () [i] = value_type ();
        }


       
        void clear () {
            std::fill (data ().begin (), data ().end (), value_type ());
        }
# 169 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp"
       
        vector &operator = (const vector &v) {
            data () = v.data ();
            return *this;
        }

        template<class C>
       
        vector &operator = (const vector_container<C> &v) {
            resize (v ().size (), false);
            assign (v);
            return *this;
        }
       
        vector &assign_temporary (vector &v) {
            swap (v);
            return *this;
        }
        template<class AE>
       
        vector &operator = (const vector_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        vector &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }


        template<class AE>
       
        vector &operator += (const vector_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        vector &operator += (const vector_container<C> &v) {
            plus_assign (v);
            return *this;
        }
        template<class AE>
       
        vector &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        vector &operator -= (const vector_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        vector &operator -= (const vector_container<C> &v) {
            minus_assign (v);
            return *this;
        }
        template<class AE>
       
        vector &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        vector &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        vector &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (vector &v) {
            if (this != &v) {
                data ().swap (v.data ());
            }
        }
       
        friend void swap (vector &v1, vector &v2) {
            v1.swap (v2);
        }


    private:

        typedef typename A::const_iterator const_subiterator_type;
        typedef typename A::iterator subiterator_type;

    public:




        class const_iterator;
        class iterator;



       
        const_iterator find (size_type i) const {

            return const_iterator (*this, data ().begin () + i);



        }
       
        iterator find (size_type i) {

            return iterator (*this, data ().begin () + i);



        }


        class const_iterator:
            public container_const_reference<vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator, value_type, difference_type> {
        public:
            typedef typename vector::difference_type difference_type;
            typedef typename vector::value_type value_type;
            typedef typename vector::const_reference reference;
            typedef const typename vector::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &v, const const_subiterator_type &it):
                container_const_reference<self_type> (v), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 340 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 347 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(it_ + n);
            }


           
            size_type index () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 358 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return it_ - (*this) ().begin ().it_;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 373 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 378 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (data_.size ());
        }


        class iterator:
            public container_reference<vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator, value_type, difference_type> {
        public:
            typedef typename vector::difference_type difference_type;
            typedef typename vector::value_type value_type;
            typedef typename vector::reference reference;
            typedef typename vector::pointer pointer;



           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &v, const subiterator_type &it):
                container_reference<self_type> (v), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 441 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 448 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(it_ + n);
            }


           
            size_type index () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 459 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return it_ - (*this) ().begin ().it_;
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 474 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 479 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };


       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (data_.size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            ar & serialization::make_nvp("data",data_);
        }

    private:
        array_type data_;
    };



    template<class T, std::size_t N>
    class bounded_vector:
        public vector<T, bounded_array<T, N> > {

        typedef vector<T, bounded_array<T, N> > vector_type;
    public:
        typedef typename vector_type::size_type size_type;
        static const size_type max_size = N;


       
        bounded_vector ():
            vector_type (N) {}
       
        bounded_vector (size_type size):
            vector_type (size) {}
       
        bounded_vector (const bounded_vector &v):
            vector_type (v) {}
        template<class A2>
       
        bounded_vector (const vector<T, A2> &v):
            vector_type (v) {}
        template<class AE>
       
        bounded_vector (const vector_expression<AE> &ae):
            vector_type (ae) {}
       
        ~bounded_vector () {}
# 572 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp"
       
        bounded_vector &operator = (const bounded_vector &v) {
            vector_type::operator = (v);
            return *this;
        }

        template<class A2>
       
        bounded_vector &operator = (const vector<T, A2> &v) {
            vector_type::operator = (v);
            return *this;
        }
        template<class C>
       
        bounded_vector &operator = (const vector_container<C> &v) {
            vector_type::operator = (v);
            return *this;
        }
        template<class AE>
       
        bounded_vector &operator = (const vector_expression<AE> &ae) {
            vector_type::operator = (ae);
            return *this;
        }
    };



    template<class T, class ALLOC>
    class zero_vector:
        public vector_container<zero_vector<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef zero_vector<T, ALLOC> self_type;
    public:



        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef sparse_tag storage_category;


       
        zero_vector ():
            vector_container<self_type> (),
            size_ (0) {}
        explicit
        zero_vector (size_type size):
            vector_container<self_type> (),
            size_ (size) {}
       
        zero_vector (const zero_vector &v):
            vector_container<self_type> (),
            size_ (v.size_) {}


       
        size_type size () const {
            return size_;
        }


       
        void resize (size_type size, bool = true) {
            size_ = size;
        }


       
        const_pointer find_element (size_type i) const {
            return & zero_;
        }


       
        const_reference operator () (size_type ) const {
            return zero_;
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }


       
        zero_vector &operator = (const zero_vector &v) {
            size_ = v.size_;
            return *this;
        }
       
        zero_vector &assign_temporary (zero_vector &v) {
            swap (v);
            return *this;
        }


       
        void swap (zero_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
            }
        }
       
        friend void swap (zero_vector &v1, zero_vector &v2) {
            v1.swap (v2);
        }


    public:
        class const_iterator;


       
        const_iterator find (size_type ) const {
            return const_iterator (*this);
        }

        class const_iterator:
            public container_const_reference<zero_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename zero_vector::difference_type difference_type;
            typedef typename zero_vector::value_type value_type;
            typedef typename zero_vector::const_reference reference;
            typedef typename zero_vector::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> () {}
           
            const_iterator (const self_type &v):
                container_const_reference<self_type> (v) {}


           
            const_iterator &operator ++ () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 717 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }
           
            const_iterator &operator -- () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 722 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }


           
            const_reference operator * () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 729 << ":" << std::endl; bad_index ().raise ();;
                return zero_;
            }


           
            size_type index () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 736 << ":" << std::endl; bad_index ().raise ();;
                return 0;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 750 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                detail::ignore_unused_variable_warning(it);
                return true;
            }
        };

        typedef const_iterator iterator;

       
        const_iterator begin () const {
            return const_iterator (*this);
        }
       
        const_iterator end () const {
            return const_iterator (*this);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }
        }

    private:
        size_type size_;
        typedef const value_type const_value_type;
        static const_value_type zero_;
    };

    template<class T, class ALLOC>
    typename zero_vector<T, ALLOC>::const_value_type zero_vector<T, ALLOC>::zero_ = T( );



    template<class T, class ALLOC>
    class unit_vector:
        public vector_container<unit_vector<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef unit_vector<T, ALLOC> self_type;
    public:



        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef sparse_tag storage_category;


       
        unit_vector ():
            vector_container<self_type> (),
            size_ (0), index_ (0) {}
       
        explicit unit_vector (size_type size, size_type index = 0):
            vector_container<self_type> (),
            size_ (size), index_ (index) {}
       
        unit_vector (const unit_vector &v):
            vector_container<self_type> (),
            size_ (v.size_), index_ (v.index_) {}


       
        size_type size () const {
            return size_;
        }
       
        size_type index () const {
            return index_;
        }


       
        void resize (size_type size, bool = true) {
            size_ = size;
        }


       
        const_pointer find_element (size_type i) const {
            if (i == index_)
                return & one_;
            else
                return & zero_;
        }


       
        const_reference operator () (size_type i) const {
            if (i == index_)
                return one_;
            else
                return zero_;
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }


       
        unit_vector &operator = (const unit_vector &v) {
            size_ = v.size_;
            index_ = v.index_;
            return *this;
        }
       
        unit_vector &assign_temporary (unit_vector &v) {
            swap (v);
            return *this;
        }


       
        void swap (unit_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
                std::swap (index_, v.index_);
            }
        }
       
        friend void swap (unit_vector &v1, unit_vector &v2) {
            v1.swap (v2);
        }


    private:

        typedef bool const_subiterator_type;
    public:
        class const_iterator;


       
        const_iterator find (size_type i) const {
            return const_iterator (*this, i <= index_);
        }

        class const_iterator:
            public container_const_reference<unit_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename unit_vector::difference_type difference_type;
            typedef typename unit_vector::value_type value_type;
            typedef typename unit_vector::const_reference reference;
            typedef typename unit_vector::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<unit_vector> (), it_ () {}
           
            const_iterator (const unit_vector &v, const const_subiterator_type &it):
                container_const_reference<unit_vector> (v), it_ (it) {}


           
            const_iterator &operator ++ () {
                if (! (it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 932 << ":" << std::endl; std::cerr << "it_" << std::endl; bad_index ().raise (); };
                it_ = !it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                if (! (!it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 938 << ":" << std::endl; std::cerr << "!it_" << std::endl; bad_index ().raise (); };
                it_ = !it_;
                return *this;
            }


           
            const_reference operator * () const {
                if (! (it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 946 << ":" << std::endl; std::cerr << "it_" << std::endl; bad_index ().raise (); };
                return one_;
            }


           
            size_type index () const {
                if (! (it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 953 << ":" << std::endl; std::cerr << "it_" << std::endl; bad_index ().raise (); };
                return (*this) ().index_;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<unit_vector>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 968 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

        typedef const_iterator iterator;

       
        const_iterator begin () const {
            return const_iterator (*this, true);
        }
       
        const_iterator end () const {
            return const_iterator (*this, false);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }
            ar & serialization::make_nvp("index", index_);
        }

    private:
        size_type size_;
        size_type index_;
        typedef const value_type const_value_type;
        static const_value_type zero_;
        static const_value_type one_;
    };

    template<class T, class ALLOC>
    typename unit_vector<T, ALLOC>::const_value_type unit_vector<T, ALLOC>::zero_ = T( );
    template<class T, class ALLOC>
    typename unit_vector<T, ALLOC>::const_value_type unit_vector<T, ALLOC>::one_ (1);



    template<class T, class ALLOC>
    class scalar_vector:
        public vector_container<scalar_vector<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef scalar_vector<T, ALLOC> self_type;
    public:



        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef dense_tag storage_category;


       
        scalar_vector ():
            vector_container<self_type> (),
            size_ (0), value_ () {}
       
        explicit scalar_vector (size_type size, const value_type &value = value_type(1)):
            vector_container<self_type> (),
            size_ (size), value_ (value) {}
       
        scalar_vector (const scalar_vector &v):
            vector_container<self_type> (),
            size_ (v.size_), value_ (v.value_) {}


       
        size_type size () const {
            return size_;
        }


       
        void resize (size_type size, bool = true) {
            size_ = size;
        }


       
        const_pointer find_element (size_type ) const {
            return & value_;
        }


       
        const_reference operator () (size_type ) const {
            return value_;
        }

       
        const_reference operator [] (size_type ) const {
            return value_;
        }


       
        scalar_vector &operator = (const scalar_vector &v) {
            size_ = v.size_;
            value_ = v.value_;
            return *this;
        }
       
        scalar_vector &assign_temporary (scalar_vector &v) {
            swap (v);
            return *this;
        }


       
        void swap (scalar_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
                std::swap (value_, v.value_);
            }
        }
       
        friend void swap (scalar_vector &v1, scalar_vector &v2) {
            v1.swap (v2);
        }


    private:

        typedef size_type const_subiterator_type;

    public:




        class const_iterator;



       
        const_iterator find (size_type i) const {
            return const_iterator (*this, i);
        }


        class const_iterator:
            public container_const_reference<scalar_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename scalar_vector::difference_type difference_type;
            typedef typename scalar_vector::value_type value_type;
            typedef typename scalar_vector::const_reference reference;
            typedef typename scalar_vector::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<scalar_vector> (), it_ () {}
           
            const_iterator (const scalar_vector &v, const const_subiterator_type &it):
                container_const_reference<scalar_vector> (v), it_ (it) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1174 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (it_ < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1181 << ":" << std::endl; std::cerr << "it_ < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) () (index ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                if (! (it_ < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1192 << ":" << std::endl; std::cerr << "it_ < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return it_;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<scalar_vector>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1207 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1212 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };

        typedef const_iterator iterator;


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size_);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }
            ar & serialization::make_nvp("value", value_);
        }

    private:
        size_type size_;
        value_type value_;
    };



    template<class T, std::size_t N>
    class c_vector:
        public vector_container<c_vector<T, N> > {

        typedef c_vector<T, N> self_type;
    public:



        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef value_type array_type[N];
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef self_type vector_temporary_type;
        typedef dense_tag storage_category;


       
        c_vector ():
            size_ (N) {}
        explicit
        c_vector (size_type size):
            size_ (size) {
            if (size_ > N)
                bad_size ().raise ();
        }
       
        c_vector (const c_vector &v):
            size_ (v.size_) {
            if (size_ > N)
                bad_size ().raise ();
            assign(v);
        }
        template<class AE>
       
        c_vector (const vector_expression<AE> &ae):
            size_ (ae ().size ()) {
            if (size_ > N)
                bad_size ().raise ();
            vector_assign<scalar_assign> (*this, ae);
        }


       
        size_type size () const {
            return size_;
        }
       
        const_pointer data () const {
            return data_;
        }
       
        pointer data () {
            return data_;
        }


       
        void resize (size_type size, bool preserve = true) {
            if (size > N)
                bad_size ().raise ();
            size_ = size;
        }


       
        pointer find_element (size_type i) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
        }
       
        const_pointer find_element (size_type i) const {
            return & data_ [i];
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1345 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }
       
        reference operator () (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1350 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return data_ [i];
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        reference insert_element (size_type i, const_reference t) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1366 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return (data_ [i] = t);
        }
       
        void erase_element (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1371 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            data_ [i] = value_type ();
        }


       
        void clear () {
            std::fill (data_, data_ + size_, value_type ());
        }
# 1391 "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp"
       
        c_vector &operator = (const c_vector &v) {
            size_ = v.size_;
            std::copy (v.data_, v.data_ + v.size_, data_);
            return *this;
        }

        template<class C>
       
        c_vector &operator = (const vector_container<C> &v) {
            resize (v ().size (), false);
            assign (v);
            return *this;
        }
       
        c_vector &assign_temporary (c_vector &v) {
            swap (v);
            return *this;
        }
        template<class AE>
       
        c_vector &operator = (const vector_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        c_vector &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }


        template<class AE>
       
        c_vector &operator += (const vector_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        c_vector &operator += (const vector_container<C> &v) {
            plus_assign (v);
            return *this;
        }
        template<class AE>
       
        c_vector &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> ( *this, ae);
            return *this;
        }
        template<class AE>
       
        c_vector &operator -= (const vector_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        c_vector &operator -= (const vector_container<C> &v) {
            minus_assign (v);
            return *this;
        }
        template<class AE>
       
        c_vector &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        c_vector &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        c_vector &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (c_vector &v) {
            if (this != &v) {
                if (! (size_ == v.size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1477 << ":" << std::endl; std::cerr << "size_ == v.size_" << std::endl; bad_size ().raise (); };
                std::swap (size_, v.size_);
                std::swap_ranges (data_, data_ + size_, v.data_);
            }
        }
       
        friend void swap (c_vector &v1, c_vector &v2) {
            v1.swap (v2);
        }


    private:

        typedef const_pointer const_subiterator_type;
        typedef pointer subiterator_type;

    public:




        class const_iterator;
        class iterator;



       
        const_iterator find (size_type i) const {

            return const_iterator (*this, &data_ [i]);



        }
       
        iterator find (size_type i) {

            return iterator (*this, &data_ [i]);



        }


        class const_iterator:
            public container_const_reference<c_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename c_vector::difference_type difference_type;
            typedef typename c_vector::value_type value_type;
            typedef typename c_vector::const_reference reference;
            typedef typename c_vector::const_pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &v, const const_subiterator_type &it):
                container_const_reference<self_type> (v), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1565 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1572 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(it_ + n);
            }


           
            size_type index () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1583 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                const self_type &v = (*this) ();
                return it_ - v.begin ().it_;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1599 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1604 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size_);
        }


        class iterator:
            public container_reference<c_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator, value_type> {
        public:
            typedef typename c_vector::difference_type difference_type;
            typedef typename c_vector::value_type value_type;
            typedef typename c_vector::reference reference;
            typedef typename c_vector::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &v, const subiterator_type &it):
                container_reference<self_type> (v), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1666 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1673 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(it_ + n);
            }


           
            size_type index () const {
                if (! (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1684 << ":" << std::endl; std::cerr << "it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_" << std::endl; bad_index ().raise (); };

                self_type &v = (*this) ();
                return it_ - v.begin ().it_;
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1701 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector.hpp" << " at line " << 1706 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };


       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size_);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);


            if (Archive::is_loading::value) {
              if (s > N) bad_size("too large size in bounded_vector::load()\n").raise();
              size_ = s;
            }

            ar & serialization::make_nvp("data",data_);
        }

    private:
        size_type size_;
        array_type data_;
    };

}}}
# 7 "/home/preben/working/CRTPlanner/Constraint.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp"
#define _BOOST_UBLAS_MATRIX_ 


# 1 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
#define _BOOST_UBLAS_MATRIX_EXPRESSION_ 
# 23 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
namespace boost { namespace numeric { namespace ublas {

    template<class E>
    class matrix_reference:
        public matrix_expression<matrix_reference<E> > {

        typedef matrix_reference<E> self_type;
    public:



        typedef typename E::size_type size_type;
        typedef typename E::difference_type difference_type;
        typedef typename E::value_type value_type;
        typedef typename E::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<E>,
                                          typename E::const_reference,
                                          typename E::reference>::type reference;
        typedef E referred_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename E::orientation_category orientation_category;
        typedef typename E::storage_category storage_category;


       
        explicit matrix_reference (referred_type &e):
              e_ (e) {}


       
        size_type size1 () const {
            return e_.size1 ();
        }
       
        size_type size2 () const {
            return e_.size2 ();
        }

    public:

       
        const referred_type &expression () const {
            return e_;
        }
       
        referred_type &expression () {
            return e_;
        }

    public:


       
        const_reference operator () (size_type i, size_type j) const {
            return expression () (i, j);
        }
       
        reference operator () (size_type i, size_type j) {
            return expression () (i, j);
        }
# 92 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
       
        matrix_reference &operator = (const matrix_reference &m) {
            expression ().operator = (m);
            return *this;
        }
        template<class AE>
       
        matrix_reference &operator = (const matrix_expression<AE> &ae) {
            expression ().operator = (ae);
            return *this;
        }
        template<class AE>
       
        matrix_reference &assign (const matrix_expression<AE> &ae) {
            expression ().assign (ae);
            return *this;
        }
        template<class AE>
       
        matrix_reference &operator += (const matrix_expression<AE> &ae) {
            expression ().operator += (ae);
            return *this;
        }
        template<class AE>
       
        matrix_reference &plus_assign (const matrix_expression<AE> &ae) {
            expression ().plus_assign (ae);
            return *this;
        }
        template<class AE>
       
        matrix_reference &operator -= (const matrix_expression<AE> &ae) {
            expression ().operator -= (ae);
            return *this;
        }
        template<class AE>
       
        matrix_reference &minus_assign (const matrix_expression<AE> &ae) {
            expression ().minus_assign (ae);
            return *this;
        }
        template<class AT>
       
        matrix_reference &operator *= (const AT &at) {
            expression ().operator *= (at);
            return *this;
        }
        template<class AT>
       
        matrix_reference &operator /= (const AT &at) {
            expression ().operator /= (at);
            return *this;
        }


       
        void swap (matrix_reference &m) {
            expression ().swap (m.expression ());
        }


       
        bool same_closure (const matrix_reference &mr) const {
            return &(*this).e_ == &mr.e_;
        }


        typedef typename E::const_iterator1 const_iterator1;
        typedef typename boost::mpl::if_<boost::is_const<E>,
                                          typename E::const_iterator1,
                                          typename E::iterator1>::type iterator1;
        typedef typename E::const_iterator2 const_iterator2;
        typedef typename boost::mpl::if_<boost::is_const<E>,
                                          typename E::const_iterator2,
                                          typename E::iterator2>::type iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            return expression ().find1 (rank, i, j);
        }
       
        iterator1 find1 (int rank, size_type i, size_type j) {
            return expression ().find1 (rank, i, j);
        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            return expression ().find2 (rank, i, j);
        }
       
        iterator2 find2 (int rank, size_type i, size_type j) {
            return expression ().find2 (rank, i, j);
        }



       
        const_iterator1 begin1 () const {
            return expression ().begin1 ();
        }
       
        const_iterator1 end1 () const {
            return expression ().end1 ();
        }

       
        iterator1 begin1 () {
            return expression ().begin1 ();
        }
       
        iterator1 end1 () {
            return expression ().end1 ();
        }

       
        const_iterator2 begin2 () const {
            return expression ().begin2 ();
        }
       
        const_iterator2 end2 () const {
            return expression ().end2 ();
        }

       
        iterator2 begin2 () {
            return expression ().begin2 ();
        }
       
        iterator2 end2 () {
            return expression ().end2 ();
        }


        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;

       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }

    private:
        referred_type &e_;
    };


    template<class E1, class E2, class F>
    class vector_matrix_binary:
        public matrix_expression<vector_matrix_binary<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef vector_matrix_binary<E1, E2, F> self_type;
    public:



        typedef F functor_type;
        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_orientation_tag orientation_category;
        typedef unknown_storage_tag storage_category;


       
        vector_matrix_binary (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size1 () const {
            return e1_.size ();
        }
       
        size_type size2 () const {
            return e2_.size ();
        }

    public:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e1_ (i), e2_ (j));
        }


       
        bool same_closure (const vector_matrix_binary &vmb) const {
            return (*this).expression1 ().same_closure (vmb.expression1 ()) &&
                   (*this).expression2 ().same_closure (vmb.expression2 ());
        }


    private:
        typedef typename E1::const_iterator const_subiterator1_type;
        typedef typename E2::const_iterator const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:
# 353 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_subiterator1_type it1 (e1_.find (i));
            const_subiterator1_type it1_end (e1_.find (size1 ()));
            const_subiterator2_type it2 (e2_.find (j));
            const_subiterator2_type it2_end (e2_.find (size2 ()));
            if (it2 == it2_end || (rank == 1 && (it2.index () != j || *it2 == value_type ()))) {
                it1 = it1_end;
                it2 = it2_end;
            }






            return const_iterator1 (*this, it1, it2);


        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_subiterator2_type it2 (e2_.find (j));
            const_subiterator2_type it2_end (e2_.find (size2 ()));
            const_subiterator1_type it1 (e1_.find (i));
            const_subiterator1_type it1_end (e1_.find (size1 ()));
            if (it1 == it1_end || (rank == 1 && (it1.index () != i || *it1 == value_type ()))) {
                it2 = it2_end;
                it1 = it1_end;
            }






            return const_iterator2 (*this, it1, it2);


        }





        class const_iterator1:
            public container_const_reference<vector_matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                                          typename E2::const_iterator::iterator_category>::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                      typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
            typedef typename vector_matrix_binary::difference_type difference_type;
            typedef typename vector_matrix_binary::value_type value_type;
            typedef typename vector_matrix_binary::const_reference reference;
            typedef typename vector_matrix_binary::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;
# 432 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2) {}



           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 463 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 464 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {



                return functor_type::apply (*it1_, *it2_);

            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;



                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 538 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 539 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 544 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 545 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:






            const_subiterator1_type it1_;
            const_subiterator2_type it2_;

        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<vector_matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                                          typename E2::const_iterator::iterator_category>::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                      typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
            typedef typename vector_matrix_binary::difference_type difference_type;
            typedef typename vector_matrix_binary::value_type value_type;
            typedef typename vector_matrix_binary::const_reference reference;
            typedef typename vector_matrix_binary::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;
# 597 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2) {}



           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure(it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 628 << ":" << std::endl; std::cerr << "(*this) ().same_closure(it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 629 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {



                return functor_type::apply (*it1_, *it2_);

            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;



                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure( it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 703 << ":" << std::endl; std::cerr << "(*this) ().same_closure( it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 704 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 709 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 710 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:






            const_subiterator1_type it1_;
            const_subiterator2_type it2_;

        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct vector_matrix_binary_traits {
        typedef vector_matrix_binary<E1, E2, F> expression_type;

        typedef expression_type result_type;




    };


    template<class E1, class E2>
   
    typename vector_matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
    outer_prod (const vector_expression<E1> &e1,
                const vector_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E1::complexity == 0 && E2::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_778;
        typedef typename vector_matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }

    template<class E, class F>
    class matrix_unary1:
        public matrix_expression<matrix_unary1<E, F> > {

        typedef E expression_type;
        typedef F functor_type;
    public:
        typedef typename E::const_closure_type expression_closure_type;
    private:
        typedef matrix_unary1<E, F> self_type;
    public:



        typedef typename E::size_type size_type;
        typedef typename E::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef typename E::orientation_category orientation_category;
        typedef unknown_storage_tag storage_category;


       
        explicit matrix_unary1 (const expression_type &e):
            e_ (e) {}


       
        size_type size1 () const {
            return e_.size1 ();
        }
       
        size_type size2 () const {
            return e_.size2 ();
        }

    public:

       
        const expression_closure_type &expression () const {
            return e_;
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e_ (i, j));
        }


       
        bool same_closure (const matrix_unary1 &mu1) const {
            return (*this).expression ().same_closure (mu1.expression ());
        }


    private:
        typedef typename E::const_iterator1 const_subiterator1_type;
        typedef typename E::const_iterator2 const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:






        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_subiterator1_type it1 (e_.find1 (rank, i, j));



            return const_iterator1 (*this, it1);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_subiterator2_type it2 (e_.find2 (rank, i, j));



            return const_iterator2 (*this, it2);

        }





        class const_iterator1:
            public container_const_reference<matrix_unary1>,
            public iterator_base_traits<typename E::const_iterator1::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename E::const_iterator1::iterator_category iterator_category;
            typedef typename matrix_unary1::difference_type difference_type;
            typedef typename matrix_unary1::value_type value_type;
            typedef typename matrix_unary1::const_reference reference;
            typedef typename matrix_unary1::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &mu, const const_subiterator1_type &it):
                container_const_reference<self_type> (mu), it_ (it) {}


           
            const_iterator1 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 932 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 ();
            }
           
            size_type index2 () const {
                return it_.index2 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 998 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1003 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator1_type it_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_unary1>,
            public iterator_base_traits<typename E::const_iterator2::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename E::const_iterator2::iterator_category iterator_category;
            typedef typename matrix_unary1::difference_type difference_type;
            typedef typename matrix_unary1::value_type value_type;
            typedef typename matrix_unary1::const_reference reference;
            typedef typename matrix_unary1::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &mu, const const_subiterator2_type &it):
                container_const_reference<self_type> (mu), it_ (it) {}


           
            const_iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1067 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 ();
            }
           
            size_type index2 () const {
                return it_.index2 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1133 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1138 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator2_type it_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression_closure_type e_;
    };

    template<class E, class F>
    struct matrix_unary1_traits {
        typedef matrix_unary1<E, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E>
   
    typename matrix_unary1_traits<E, scalar_negate<typename E::value_type> >::result_type
    operator - (const matrix_expression<E> &e) {
        typedef typename matrix_unary1_traits<E, scalar_negate<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::result_type
    conj (const matrix_expression<E> &e) {
        typedef typename matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename matrix_unary1_traits<E, scalar_real<typename E::value_type> >::result_type
    real (const matrix_expression<E> &e) {
        typedef typename matrix_unary1_traits<E, scalar_real<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::result_type
    imag (const matrix_expression<E> &e) {
        typedef typename matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E, class F>
    class matrix_unary2:
        public matrix_expression<matrix_unary2<E, F> > {

        typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<typename E::value_type> >,
                                          E,
                                          const E>::type expression_type;
        typedef F functor_type;
    public:
        typedef typename boost::mpl::if_<boost::is_const<expression_type>,
                                          typename E::const_closure_type,
                                          typename E::closure_type>::type expression_closure_type;
    private:
        typedef matrix_unary2<E, F> self_type;
    public:



        typedef typename E::size_type size_type;
        typedef typename E::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<value_type> >,
                                          typename E::reference,
                                          value_type>::type reference;

        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename boost::mpl::if_<boost::is_same<typename E::orientation_category,
                                                         row_major_tag>,
                                          column_major_tag,
                typename boost::mpl::if_<boost::is_same<typename E::orientation_category,
                                                         column_major_tag>,
                                          row_major_tag,
                                          typename E::orientation_category>::type>::type orientation_category;
        typedef typename E::storage_category storage_category;


       


        explicit matrix_unary2 (expression_type &e):
            e_ (e) {}


       
        size_type size1 () const {
            return e_.size2 ();
        }
       
        size_type size2 () const {
            return e_.size1 ();
        }

    public:

       
        const expression_closure_type &expression () const {
            return e_;
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e_ (j, i));
        }
       
        reference operator () (size_type i, size_type j) {
            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<functor_type, scalar_identity<value_type > >::value)) == 0 ? false : true) >)> boost_static_assert_typedef_1295;
            return e_ (j, i);
        }


       
        bool same_closure (const matrix_unary2 &mu2) const {
            return (*this).expression ().same_closure (mu2.expression ());
        }


    private:
        typedef typename E::const_iterator1 const_subiterator2_type;
        typedef typename E::const_iterator2 const_subiterator1_type;
        typedef const value_type *const_pointer;

    public:






        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_subiterator1_type it1 (e_.find2 (rank, j, i));



            return const_iterator1 (*this, it1);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_subiterator2_type it2 (e_.find1 (rank, j, i));



            return const_iterator2 (*this, it2);

        }





        class const_iterator1:
            public container_const_reference<matrix_unary2>,
            public iterator_base_traits<typename E::const_iterator2::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename E::const_iterator2::iterator_category iterator_category;
            typedef typename matrix_unary2::difference_type difference_type;
            typedef typename matrix_unary2::value_type value_type;
            typedef typename matrix_unary2::const_reference reference;
            typedef typename matrix_unary2::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &mu, const const_subiterator1_type &it):
                container_const_reference<self_type> (mu), it_ (it) {}


           
            const_iterator1 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1395 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it_.index2 ();
            }
           
            size_type index2 () const {
                return it_.index1 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1461 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1466 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator1_type it_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_unary2>,
            public iterator_base_traits<typename E::const_iterator1::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename E::const_iterator1::iterator_category iterator_category;
            typedef typename matrix_unary2::difference_type difference_type;
            typedef typename matrix_unary2::value_type value_type;
            typedef typename matrix_unary2::const_reference reference;
            typedef typename matrix_unary2::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &mu, const const_subiterator2_type &it):
                container_const_reference<self_type> (mu), it_ (it) {}


           
            const_iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1530 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it_.index2 ();
            }
           
            size_type index2 () const {
                return it_.index1 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1596 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1601 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator2_type it_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression_closure_type e_;
    };

    template<class E, class F>
    struct matrix_unary2_traits {
        typedef matrix_unary2<E, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E>
   
    typename matrix_unary2_traits<const E, scalar_identity<typename E::value_type> >::result_type
    trans (const matrix_expression<E> &e) {
        typedef typename matrix_unary2_traits<const E, scalar_identity<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }
    template<class E>
   
    typename matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::result_type
    trans (matrix_expression<E> &e) {
        typedef typename matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }


    template<class E>
   
    typename matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::result_type
    herm (const matrix_expression<E> &e) {
        typedef typename matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E1, class E2, class F>
    class matrix_binary:
        public matrix_expression<matrix_binary<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef matrix_binary<E1, E2, F> self_type;
    public:



        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_orientation_tag orientation_category;
        typedef unknown_storage_tag storage_category;


       
        matrix_binary (const E1 &e1, const E2 &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size1 () const {
            return same_impl_ex ((e1_.size1 ()), (e2_.size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp", 1712);
        }
       
        size_type size2 () const {
            return same_impl_ex ((e1_.size2 ()), (e2_.size2 ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp", 1716);
        }

    public:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e1_ (i, j), e2_ (i, j));
        }


       
        bool same_closure (const matrix_binary &mb) const {
            return (*this).expression1 ().same_closure (mb.expression1 ()) &&
                   (*this).expression2 ().same_closure (mb.expression2 ());
        }


    private:
        typedef typename E1::const_iterator1 const_iterator11_type;
        typedef typename E1::const_iterator2 const_iterator12_type;
        typedef typename E2::const_iterator1 const_iterator21_type;
        typedef typename E2::const_iterator2 const_iterator22_type;
        typedef const value_type *const_pointer;

    public:
# 1763 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_iterator11_type it11 (e1_.find1 (rank, i, j));
            const_iterator11_type it11_end (e1_.find1 (rank, size1 (), j));
            const_iterator21_type it21 (e2_.find1 (rank, i, j));
            const_iterator21_type it21_end (e2_.find1 (rank, size1 (), j));
            if (! (rank == 0 || it11 == it11_end || it11.index2 () == j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1778 << ":" << std::endl; std::cerr << "rank == 0 || it11 == it11_end || it11.index2 () == j" << std::endl; internal_logic ().raise (); }
            if (! (rank == 0 || it21 == it21_end || it21.index2 () == j)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1779 << ":" << std::endl; std::cerr << "rank == 0 || it21 == it21_end || it21.index2 () == j" << std::endl; internal_logic ().raise (); }
            i = (std::min) (it11 != it11_end ? it11.index1 () : size1 (),
                          it21 != it21_end ? it21.index1 () : size1 ());



            return const_iterator1 (*this, i, j, it11, it11_end, it21, it21_end);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_iterator12_type it12 (e1_.find2 (rank, i, j));
            const_iterator12_type it12_end (e1_.find2 (rank, i, size2 ()));
            const_iterator22_type it22 (e2_.find2 (rank, i, j));
            const_iterator22_type it22_end (e2_.find2 (rank, i, size2 ()));
            if (! (rank == 0 || it12 == it12_end || it12.index1 () == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1794 << ":" << std::endl; std::cerr << "rank == 0 || it12 == it12_end || it12.index1 () == i" << std::endl; internal_logic ().raise (); }
            if (! (rank == 0 || it22 == it22_end || it22.index1 () == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1795 << ":" << std::endl; std::cerr << "rank == 0 || it22 == it22_end || it22.index1 () == i" << std::endl; internal_logic ().raise (); }
            j = (std::min) (it12 != it12_end ? it12.index2 () : size2 (),
                          it22 != it22_end ? it22.index2 () : size2 ());



            return const_iterator2 (*this, i, j, it12, it12_end, it22, it22_end);

        }





        class const_iterator1:
            public container_const_reference<matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                                          typename E2::const_iterator1::iterator_category>::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                      typename E2::const_iterator1::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_binary::difference_type difference_type;
            typedef typename matrix_binary::value_type value_type;
            typedef typename matrix_binary::const_reference reference;
            typedef typename matrix_binary::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), i_ (), j_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
           
            const_iterator1 (const self_type &mb, size_type i, size_type j,
                             const const_iterator11_type &it1, const const_iterator11_type &it1_end,
                             const const_iterator21_type &it2, const const_iterator21_type &it2_end):
                container_const_reference<self_type> (mb), i_ (i), j_ (j), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}

        private:

           
            void increment (dense_random_access_iterator_tag) {
                ++ i_; ++ it1_; ++ it2_;
            }
           
            void decrement (dense_random_access_iterator_tag) {
                -- i_; -- it1_; -- it2_;
            }
           
            void increment (dense_random_access_iterator_tag, difference_type n) {
                 i_ += n; it1_ += n; it2_ += n;
            }
           
            void decrement (dense_random_access_iterator_tag, difference_type n) {
                i_ -= n; it1_ -= n; it2_ -= n;
            }
           
            value_type dereference (dense_random_access_iterator_tag) const {
                return functor_type::apply (*it1_, *it2_);
            }


           
            void increment (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (it1_.index1 () <= i_)
                        ++ it1_;
                if (it2_ != it2_end_)
                    if (it2_.index1 () <= i_)
                        ++ it2_;
                ++ i_;
            }
           
            void decrement (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (i_ <= it1_.index1 ())
                        -- it1_;
                if (it2_ != it2_end_)
                    if (i_ <= it2_.index1 ())
                        -- it2_;
                -- i_;
            }
           
            void increment (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (packed_random_access_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_) {
                    if (! (it1_.index2 () == j_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1905 << ":" << std::endl; std::cerr << "it1_.index2 () == j_" << std::endl; internal_logic ().raise (); };
                    if (it1_.index1 () == i_)
                        t1 = *it1_;
                }
                value_type t2 = value_type ();
                if (it2_ != it2_end_) {
                    if (! (it2_.index2 () == j_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1911 << ":" << std::endl; std::cerr << "it2_.index2 () == j_" << std::endl; internal_logic ().raise (); };
                    if (it2_.index1 () == i_)
                        t2 = *it2_;
                }
                return functor_type::apply (t1, t2);
            }


           
            void increment (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size1 ();
                if (it1_ != it1_end_) {
                    if (it1_.index1 () <= i_)
                        ++ it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index1 ();
                }
                size_type index2 = (*this) ().size1 ();
                if (it2_ != it2_end_)
                    if (it2_.index1 () <= i_)
                        ++ it2_;
                    if (it2_ != it2_end_) {
                        index2 = it2_.index1 ();
                }
                i_ = (std::min) (index1, index2);
            }
           
            void decrement (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size1 ();
                if (it1_ != it1_end_) {
                    if (i_ <= it1_.index1 ())
                        -- it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index1 ();
                }
                size_type index2 = (*this) ().size1 ();
                if (it2_ != it2_end_) {
                    if (i_ <= it2_.index1 ())
                        -- it2_;
                    if (it2_ != it2_end_)
                        index2 = it2_.index1 ();
                }
                i_ = (std::max) (index1, index2);
            }
           
            void increment (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (sparse_bidirectional_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_) {
                    if (! (it1_.index2 () == j_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1981 << ":" << std::endl; std::cerr << "it1_.index2 () == j_" << std::endl; internal_logic ().raise (); };
                    if (it1_.index1 () == i_)
                        t1 = *it1_;
                }
                value_type t2 = value_type ();
                if (it2_ != it2_end_) {
                    if (! (it2_.index2 () == j_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 1987 << ":" << std::endl; std::cerr << "it2_.index2 () == j_" << std::endl; internal_logic ().raise (); };
                    if (it2_.index1 () == i_)
                        t2 = *it2_;
                }
                return functor_type::apply (t1, t2);
            }

        public:

           
            const_iterator1 &operator ++ () {
                increment (iterator_category ());
                return *this;
            }
           
            const_iterator1 &operator -- () {
                decrement (iterator_category ());
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                increment (iterator_category (), n);
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                decrement (iterator_category (), n);
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2018 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2019 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; external_logic ().raise (); };
                return index1 () - it.index1 ();
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return i_;
            }
           
            size_type index2 () const {



                    return j_;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                i_ = it.i_;
                j_ = it.j_;
                it1_ = it.it1_;
                it1_end_ = it.it1_end_;
                it2_ = it.it2_;
                it2_end_ = it.it2_end_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2093 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2094 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; external_logic ().raise (); };
                return index1 () == it.index1 ();
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2099 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2100 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; external_logic ().raise (); };
                return index1 () < it.index1 ();
            }

        private:
            size_type i_;
            size_type j_;
            const_iterator11_type it1_;
            const_iterator11_type it1_end_;
            const_iterator21_type it2_;
            const_iterator21_type it2_end_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator2::iterator_category,
                                                                          typename E2::const_iterator2::iterator_category>::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator2::iterator_category,
                                                      typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_binary::difference_type difference_type;
            typedef typename matrix_binary::value_type value_type;
            typedef typename matrix_binary::const_reference reference;
            typedef typename matrix_binary::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), i_ (), j_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
           
            const_iterator2 (const self_type &mb, size_type i, size_type j,
                             const const_iterator12_type &it1, const const_iterator12_type &it1_end,
                             const const_iterator22_type &it2, const const_iterator22_type &it2_end):
                container_const_reference<self_type> (mb), i_ (i), j_ (j), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}

        private:

           
            void increment (dense_random_access_iterator_tag) {
                ++ j_; ++ it1_; ++ it2_;
            }
           
            void decrement (dense_random_access_iterator_tag) {
                -- j_; -- it1_; -- it2_;
            }
           
            void increment (dense_random_access_iterator_tag, difference_type n) {
                j_ += n; it1_ += n; it2_ += n;
            }
           
            void decrement (dense_random_access_iterator_tag, difference_type n) {
                j_ -= n; it1_ -= n; it2_ -= n;
            }
           
            value_type dereference (dense_random_access_iterator_tag) const {
                return functor_type::apply (*it1_, *it2_);
            }


           
            void increment (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (it1_.index2 () <= j_)
                        ++ it1_;
                if (it2_ != it2_end_)
                    if (it2_.index2 () <= j_)
                        ++ it2_;
                ++ j_;
            }
           
            void decrement (packed_random_access_iterator_tag) {
                if (it1_ != it1_end_)
                    if (j_ <= it1_.index2 ())
                        -- it1_;
                if (it2_ != it2_end_)
                    if (j_ <= it2_.index2 ())
                        -- it2_;
                -- j_;
            }
           
            void increment (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (packed_random_access_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (packed_random_access_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (packed_random_access_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (packed_random_access_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_) {
                    if (! (it1_.index1 () == i_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2220 << ":" << std::endl; std::cerr << "it1_.index1 () == i_" << std::endl; internal_logic ().raise (); };
                    if (it1_.index2 () == j_)
                        t1 = *it1_;
                }
                value_type t2 = value_type ();
                if (it2_ != it2_end_) {
                    if (! (it2_.index1 () == i_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2226 << ":" << std::endl; std::cerr << "it2_.index1 () == i_" << std::endl; internal_logic ().raise (); };
                    if (it2_.index2 () == j_)
                        t2 = *it2_;
                }
                return functor_type::apply (t1, t2);
            }


           
            void increment (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size2 ();
                if (it1_ != it1_end_) {
                    if (it1_.index2 () <= j_)
                        ++ it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index2 ();
                }
                size_type index2 = (*this) ().size2 ();
                if (it2_ != it2_end_) {
                    if (it2_.index2 () <= j_)
                        ++ it2_;
                    if (it2_ != it2_end_)
                        index2 = it2_.index2 ();
                }
                j_ = (std::min) (index1, index2);
            }
           
            void decrement (sparse_bidirectional_iterator_tag) {
                size_type index1 = (*this) ().size2 ();
                if (it1_ != it1_end_) {
                    if (j_ <= it1_.index2 ())
                        -- it1_;
                    if (it1_ != it1_end_)
                        index1 = it1_.index2 ();
                }
                size_type index2 = (*this) ().size2 ();
                if (it2_ != it2_end_) {
                    if (j_ <= it2_.index2 ())
                        -- it2_;
                    if (it2_ != it2_end_)
                        index2 = it2_.index2 ();
                }
                j_ = (std::max) (index1, index2);
            }
           
            void increment (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
                while (n > 0) {
                    decrement (sparse_bidirectional_iterator_tag ());
                    --n;
                }
                while (n < 0) {
                    increment (sparse_bidirectional_iterator_tag ());
                    ++n;
                }
            }
           
            value_type dereference (sparse_bidirectional_iterator_tag) const {
                value_type t1 = value_type ();
                if (it1_ != it1_end_) {
                    if (! (it1_.index1 () == i_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2296 << ":" << std::endl; std::cerr << "it1_.index1 () == i_" << std::endl; internal_logic ().raise (); };
                    if (it1_.index2 () == j_)
                        t1 = *it1_;
                }
                value_type t2 = value_type ();
                if (it2_ != it2_end_) {
                    if (! (it2_.index1 () == i_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2302 << ":" << std::endl; std::cerr << "it2_.index1 () == i_" << std::endl; internal_logic ().raise (); };
                    if (it2_.index2 () == j_)
                        t2 = *it2_;
                }
                return functor_type::apply (t1, t2);
            }

        public:

           
            const_iterator2 &operator ++ () {
                increment (iterator_category ());
                return *this;
            }
           
            const_iterator2 &operator -- () {
                decrement (iterator_category ());
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                increment (iterator_category (), n);
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                decrement (iterator_category (), n);
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2333 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2334 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; external_logic ().raise (); };
                return index2 () - it.index2 ();
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {



                    return i_;
            }
           
            size_type index2 () const {
                return j_;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                i_ = it.i_;
                j_ = it.j_;
                it1_ = it.it1_;
                it1_end_ = it.it1_end_;
                it2_ = it.it2_;
                it2_end_ = it.it2_end_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2408 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2409 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; external_logic ().raise (); };
                return index2 () == it.index2 ();
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2414 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2415 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; external_logic ().raise (); };
                return index2 () < it.index2 ();
            }

        private:
            size_type i_;
            size_type j_;
            const_iterator12_type it1_;
            const_iterator12_type it1_end_;
            const_iterator22_type it2_;
            const_iterator22_type it2_end_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct matrix_binary_traits {
        typedef matrix_binary<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E1, class E2>
   
    typename matrix_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
                                                      typename E2::value_type> >::result_type
    operator + (const matrix_expression<E1> &e1,
                const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
                                                                  typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
                                                       typename E2::value_type> >::result_type
    operator - (const matrix_expression<E1> &e1,
                const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
                                                                   typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
                                                            typename E2::value_type> >::result_type
    element_prod (const matrix_expression<E1> &e1,
                  const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
                                                                        typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                         typename E2::value_type> >::result_type
    element_div (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                                     typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }

    template<class E1, class E2, class F>
    class matrix_binary_scalar1:
        public matrix_expression<matrix_binary_scalar1<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
        typedef const E1& expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
        typedef matrix_binary_scalar1<E1, E2, F> self_type;
    public:



        typedef typename E2::size_type size_type;
        typedef typename E2::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef typename E2::orientation_category orientation_category;
        typedef unknown_storage_tag storage_category;


       
        matrix_binary_scalar1 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size1 () const {
            return e2_.size1 ();
        }
       
        size_type size2 () const {
            return e2_.size2 ();
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (expression1_type (e1_), e2_ (i, j));
        }


       
        bool same_closure (const matrix_binary_scalar1 &mbs1) const {
            return &e1_ == &(mbs1.e1_) &&
                   (*this).e2_.same_closure (mbs1.e2_);
        }


    private:
        typedef expression1_type const_subiterator1_type;
        typedef typename E2::const_iterator1 const_iterator21_type;
        typedef typename E2::const_iterator2 const_iterator22_type;
        typedef const value_type *const_pointer;

    public:






        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_iterator21_type it21 (e2_.find1 (rank, i, j));



            return const_iterator1 (*this, const_subiterator1_type (e1_), it21);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_iterator22_type it22 (e2_.find2 (rank, i, j));



            return const_iterator2 (*this, const_subiterator1_type (e1_), it22);

        }





        class const_iterator1:
            public container_const_reference<matrix_binary_scalar1>,
            public iterator_base_traits<typename E2::const_iterator1::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename E2::const_iterator1::iterator_category iterator_category;
            typedef typename matrix_binary_scalar1::difference_type difference_type;
            typedef typename matrix_binary_scalar1::value_type value_type;
            typedef typename matrix_binary_scalar1::const_reference reference;
            typedef typename matrix_binary_scalar1::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator21_type &it2):
                container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator1 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it2_ ;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2665 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it2_.index1 ();
            }
           
            size_type index2 () const {
                return it2_.index2 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2734 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2741 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_iterator21_type it2_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_binary_scalar1>,
            public iterator_base_traits<typename E2::const_iterator2::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename E2::const_iterator2::iterator_category iterator_category;
            typedef typename matrix_binary_scalar1::difference_type difference_type;
            typedef typename matrix_binary_scalar1::value_type value_type;
            typedef typename matrix_binary_scalar1::const_reference reference;
            typedef typename matrix_binary_scalar1::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator22_type &it2):
                container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2808 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it2_.index1 ();
            }
           
            size_type index2 () const {
                return it2_.index2 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2877 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 2884 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_iterator22_type it2_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct matrix_binary_scalar1_traits {
        typedef matrix_binary_scalar1<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class T1, class E2>
   
    typename enable_if< is_convertible<T1, typename E2::value_type >,
    typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
    >::type
    operator * (const T1 &e1,
                const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1, e2 ());
    }


    template<class E1, class E2, class F>
    class matrix_binary_scalar2:
        public matrix_expression<matrix_binary_scalar2<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef const E2& expression2_closure_type;
    private:
        typedef matrix_binary_scalar2<E1, E2, F> self_type;
    public:



        typedef typename E1::size_type size_type;
        typedef typename E1::difference_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;

        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef typename E1::orientation_category orientation_category;
        typedef unknown_storage_tag storage_category;


       
        matrix_binary_scalar2 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size1 () const {
            return e1_.size1 ();
        }
       
        size_type size2 () const {
            return e1_.size2 ();
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e1_ (i, j), expression2_type (e2_));
        }


       
        bool same_closure (const matrix_binary_scalar2 &mbs2) const {
            return (*this).e1_.same_closure (mbs2.e1_) &&
                   &e2_ == &(mbs2.e2_);
        }


    private:
        typedef typename E1::const_iterator1 const_iterator11_type;
        typedef typename E1::const_iterator2 const_iterator12_type;
        typedef expression2_type const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:






        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_iterator11_type it11 (e1_.find1 (rank, i, j));



            return const_iterator1 (*this, it11, const_subiterator2_type (e2_));

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_iterator12_type it12 (e1_.find2 (rank, i, j));



            return const_iterator2 (*this, it12, const_subiterator2_type (e2_));

        }





        class const_iterator1:
            public container_const_reference<matrix_binary_scalar2>,
            public iterator_base_traits<typename E1::const_iterator1::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename E1::const_iterator1::iterator_category iterator_category;
            typedef typename matrix_binary_scalar2::difference_type difference_type;
            typedef typename matrix_binary_scalar2::value_type value_type;
            typedef typename matrix_binary_scalar2::const_reference reference;
            typedef typename matrix_binary_scalar2::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &mbs, const const_iterator11_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_ ;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3100 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it1_, it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index1 ();
            }
           
            size_type index2 () const {
                return it1_.index2 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3169 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3176 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ < it.it1_;
            }

        private:
            const_iterator11_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_binary_scalar2>,
            public iterator_base_traits<typename E1::const_iterator2::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename E1::const_iterator2::iterator_category iterator_category;
            typedef typename matrix_binary_scalar2::difference_type difference_type;
            typedef typename matrix_binary_scalar2::value_type value_type;
            typedef typename matrix_binary_scalar2::const_reference reference;
            typedef typename matrix_binary_scalar2::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &mbs, const const_iterator12_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}


           
            const_iterator2 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3243 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                return functor_type::apply (*it1_, it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index1 ();
            }
           
            size_type index2 () const {
                return it1_.index2 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3312 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3319 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };


                return it1_ < it.it1_;
            }

        private:
            const_iterator12_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class E1, class E2, class F>
    struct matrix_binary_scalar2_traits {
        typedef matrix_binary_scalar2<E1, E2, F> expression_type;

        typedef expression_type result_type;



    };


    template<class E1, class T2>
   
    typename enable_if< is_convertible<T2, typename E1::value_type>,
    typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
    >::type
    operator * (const matrix_expression<E1> &e1,
                const T2 &e2) {
        typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
        return expression_type (e1 (), e2);
    }


    template<class E1, class T2>
   
    typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
    operator / (const matrix_expression<E1> &e1,
                const T2 &e2) {
        typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
        return expression_type (e1 (), e2);
    }


    template<class E1, class E2, class F>
    class matrix_vector_binary1:
        public vector_expression<matrix_vector_binary1<E1, E2, F> > {

    public:
        typedef E1 expression1_type;
        typedef E2 expression2_type;
    private:
        typedef F functor_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef matrix_vector_binary1<E1, E2, F> self_type;
    public:



        static const unsigned complexity = 1;
        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        matrix_vector_binary1 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size () const {
            return e1_.size1 ();
        }

    public:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:

       
        const_reference operator () (size_type i) const {
            return functor_type::apply (e1_, e2_, i);
        }


       
        bool same_closure (const matrix_vector_binary1 &mvb1) const {
            return (*this).expression1 ().same_closure (mvb1.expression1 ()) &&
                   (*this).expression2 ().same_closure (mvb1.expression2 ());
        }


    private:
        typedef typename E1::const_iterator1 const_subiterator1_type;
        typedef typename E2::const_iterator const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:




        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type i) const {




            return const_iterator (*this, e1_.find1 (0, i, 0));

        }



        class const_iterator:
            public container_const_reference<matrix_vector_binary1>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                                          typename E2::const_iterator::iterator_category>::iterator_category>::template
                iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                      typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_vector_binary1::difference_type difference_type;
            typedef typename matrix_vector_binary1::value_type value_type;
            typedef typename matrix_vector_binary1::const_reference reference;
            typedef typename matrix_vector_binary1::const_pointer pointer;
# 3512 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator ():
                container_const_reference<self_type> (), it1_ () {}
           
            const_iterator (const self_type &mvb, const const_subiterator1_type &it1):
                container_const_reference<self_type> (mvb), it1_ (it1) {}


        private:

           
            value_type dereference (dense_random_access_iterator_tag) const {
                const self_type &mvb = (*this) ();

                return mvb (index ());
# 3545 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
            }


           
            value_type dereference (packed_random_access_iterator_tag) const {



                const self_type &mvb = (*this) ();

                return functor_type::apply (it1_.begin (), it1_.end (),
                                        mvb.expression2 ().begin (), mvb.expression2 ().end ());






            }


           
            value_type dereference (sparse_bidirectional_iterator_tag) const {



                const self_type &mvb = (*this) ();

                return functor_type::apply (it1_.begin (), it1_.end (),
                                        mvb.expression2 ().begin (), mvb.expression2 ().end (), sparse_bidirectional_iterator_tag ());






            }

        public:

           
            const_iterator &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3607 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it1_.index1 ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;




                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3642 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3647 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            const_subiterator1_type it1_;





        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class T1, class E1, class T2, class E2>
    struct matrix_vector_binary1_traits {
        typedef unknown_storage_tag storage_category;
        typedef row_major_tag orientation_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_vector_binary1<E1, E2, matrix_vector_prod1<E1, E2, promote_type> > expression_type;

        typedef expression_type result_type;



    };

    template<class E1, class E2>
   
    typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                          typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const vector_expression<E2> &e2,
          unknown_storage_tag,
          row_major_tag) {
        typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                          typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const vector_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E2::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_3720;
        typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::storage_category storage_category;
        typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::orientation_category orientation_category;
        return prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class E1, class E2>
   
    typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                          typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const vector_expression<E2> &e2,
               unknown_storage_tag,
               row_major_tag) {
        typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                          typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const vector_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E2::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_3748;
        typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
        typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
        return prec_prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class V, class E1, class E2>
   
    V &
    prod (const matrix_expression<E1> &e1,
          const vector_expression<E2> &e2,
          V &v) {
        return v.assign (prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V &
    prec_prod (const matrix_expression<E1> &e1,
               const vector_expression<E2> &e2,
               V &v) {
        return v.assign (prec_prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V
    prod (const matrix_expression<E1> &e1,
          const vector_expression<E2> &e2) {
        return V (prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V
    prec_prod (const matrix_expression<E1> &e1,
               const vector_expression<E2> &e2) {
        return V (prec_prod (e1, e2));
    }

    template<class E1, class E2, class F>
    class matrix_vector_binary2:
        public vector_expression<matrix_vector_binary2<E1, E2, F> > {

        typedef E1 expression1_type;
        typedef E2 expression2_type;
        typedef F functor_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef matrix_vector_binary2<E1, E2, F> self_type;
    public:



        static const unsigned complexity = 1;
        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_storage_tag storage_category;


       
        matrix_vector_binary2 (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size () const {
            return e2_.size2 ();
        }

    public:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }
    public:


       
        const_reference operator () (size_type j) const {
            return functor_type::apply (e1_, e2_, j);
        }


       
        bool same_closure (const matrix_vector_binary2 &mvb2) const {
            return (*this).expression1 ().same_closure (mvb2.expression1 ()) &&
                   (*this).expression2 ().same_closure (mvb2.expression2 ());
        }


    private:
        typedef typename E1::const_iterator const_subiterator1_type;
        typedef typename E2::const_iterator2 const_subiterator2_type;
        typedef const value_type *const_pointer;

    public:




        class const_iterator;
        typedef const_iterator iterator;



       
        const_iterator find (size_type j) const {




            return const_iterator (*this, e2_.find2 (0, 0, j));

        }



        class const_iterator:
            public container_const_reference<matrix_vector_binary2>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                                          typename E2::const_iterator2::iterator_category>::iterator_category>::template
                iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
                                                      typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_vector_binary2::difference_type difference_type;
            typedef typename matrix_vector_binary2::value_type value_type;
            typedef typename matrix_vector_binary2::const_reference reference;
            typedef typename matrix_vector_binary2::const_pointer pointer;
# 3902 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator ():
                container_const_reference<self_type> (), it2_ () {}
           
            const_iterator (const self_type &mvb, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mvb), it2_ (it2) {}


        private:

           
            value_type dereference (dense_random_access_iterator_tag) const {
                const self_type &mvb = (*this) ();

                return mvb (index ());
# 3935 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
            }


           
            value_type dereference (packed_random_access_iterator_tag) const {



                const self_type &mvb = (*this) ();

                return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
                                        it2_.begin (), it2_.end ());






            }


           
            value_type dereference (sparse_bidirectional_iterator_tag) const {



                const self_type &mvb = (*this) ();

                return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
                                        it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());






            }

        public:

           
            const_iterator &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 3997 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it2_.index2 ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it2_ = it.it2_;




                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4032 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4037 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            const_subiterator2_type it2_;





        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class T1, class E1, class T2, class E2>
    struct matrix_vector_binary2_traits {
        typedef unknown_storage_tag storage_category;
        typedef column_major_tag orientation_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_vector_binary2<E1, E2, matrix_vector_prod2<E1, E2, promote_type> > expression_type;

        typedef expression_type result_type;



    };

    template<class E1, class E2>
   
    typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                          typename E2::value_type, E2>::result_type
    prod (const vector_expression<E1> &e1,
          const matrix_expression<E2> &e2,
          unknown_storage_tag,
          column_major_tag) {
        typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                          typename E2::value_type, E2>::result_type
    prod (const vector_expression<E1> &e1,
          const matrix_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E1::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_4110;
        typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::storage_category storage_category;
        typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                                      typename E2::value_type, E2>::orientation_category orientation_category;
        return prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class E1, class E2>
   
    typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                          typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const vector_expression<E1> &e1,
               const matrix_expression<E2> &e2,
               unknown_storage_tag,
               column_major_tag) {
        typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                          typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const vector_expression<E1> &e1,
               const matrix_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E1::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_4138;
        typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
        typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                      typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
        return prec_prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class V, class E1, class E2>
   
    V &
    prod (const vector_expression<E1> &e1,
          const matrix_expression<E2> &e2,
          V &v) {
        return v.assign (prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V &
    prec_prod (const vector_expression<E1> &e1,
               const matrix_expression<E2> &e2,
               V &v) {
        return v.assign (prec_prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V
    prod (const vector_expression<E1> &e1,
          const matrix_expression<E2> &e2) {
        return V (prod (e1, e2));
    }

    template<class V, class E1, class E2>
   
    V
    prec_prod (const vector_expression<E1> &e1,
               const matrix_expression<E2> &e2) {
        return V (prec_prod (e1, e2));
    }

    template<class E1, class E2, class F>
    class matrix_matrix_binary:
        public matrix_expression<matrix_matrix_binary<E1, E2, F> > {

    public:
        typedef E1 expression1_type;
        typedef E2 expression2_type;
    private:
        typedef F functor_type;
    public:
        typedef typename E1::const_closure_type expression1_closure_type;
        typedef typename E2::const_closure_type expression2_closure_type;
    private:
        typedef matrix_matrix_binary<E1, E2, F> self_type;
    public:



        static const unsigned complexity = 1;
        typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
        typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
        typedef typename F::result_type value_type;
        typedef value_type const_reference;
        typedef const_reference reference;
        typedef const self_type const_closure_type;
        typedef const_closure_type closure_type;
        typedef unknown_orientation_tag orientation_category;
        typedef unknown_storage_tag storage_category;


       
        matrix_matrix_binary (const expression1_type &e1, const expression2_type &e2):
            e1_ (e1), e2_ (e2) {}


       
        size_type size1 () const {
            return e1_.size1 ();
        }
       
        size_type size2 () const {
            return e2_.size2 ();
        }

    public:

       
        const expression1_closure_type &expression1 () const {
            return e1_;
        }
       
        const expression2_closure_type &expression2 () const {
            return e2_;
        }

    public:

       
        const_reference operator () (size_type i, size_type j) const {
            return functor_type::apply (e1_, e2_, i, j);
        }


       
        bool same_closure (const matrix_matrix_binary &mmb) const {
            return (*this).expression1 ().same_closure (mmb.expression1 ()) &&
                   (*this).expression2 ().same_closure (mmb.expression2 ());
        }


    private:
        typedef typename E1::const_iterator1 const_iterator11_type;
        typedef typename E1::const_iterator2 const_iterator12_type;
        typedef typename E2::const_iterator1 const_iterator21_type;
        typedef typename E2::const_iterator2 const_iterator22_type;
        typedef const value_type *const_pointer;

    public:
# 4266 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
        class const_iterator1;
        typedef const_iterator1 iterator1;
        class const_iterator2;
        typedef const_iterator2 iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {


            const_iterator11_type it11 (e1_.find1 (0, i, 0));





            const_iterator22_type it22 (e2_.find2 (0, 0, j));
            return const_iterator1 (*this, it11, it22);

        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {


            const_iterator22_type it22 (e2_.find2 (0, 0, j));





            const_iterator11_type it11 (e1_.find1 (0, i, 0));
            return const_iterator2 (*this, it11, it22);

        }



        class const_iterator1:
            public container_const_reference<matrix_matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                                          typename E2::const_iterator2::iterator_category>::iterator_category>::template
                iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                      typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_matrix_binary::difference_type difference_type;
            typedef typename matrix_matrix_binary::value_type value_type;
            typedef typename matrix_matrix_binary::const_reference reference;
            typedef typename matrix_matrix_binary::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;
# 4331 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
                container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2) {}


        private:

           
            value_type dereference (dense_random_access_iterator_tag) const {
                const self_type &mmb = (*this) ();

                return mmb (index1 (), index2 ());
# 4364 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
            }


           
            value_type dereference (packed_random_access_iterator_tag) const {





                return functor_type::apply (it1_.begin (), it1_.end (),
                                        it2_.begin (), it2_.end (), packed_random_access_iterator_tag ());







            }


           
            value_type dereference (sparse_bidirectional_iterator_tag) const {





                return functor_type::apply (it1_.begin (), it1_.end (),
                                        it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());







            }

        public:

           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4428 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4429 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return (*this) ().find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index1 ();
            }
           
            size_type index2 () const {
                return it2_.index2 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;




                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4500 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4501 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4506 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4507 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            const_iterator11_type it1_;

                        const_iterator22_type it2_;




        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_matrix_binary>,
            public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                                          typename E2::const_iterator2::iterator_category>::iterator_category>::template
                iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
                                                      typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
            typedef typename matrix_matrix_binary::difference_type difference_type;
            typedef typename matrix_matrix_binary::value_type value_type;
            typedef typename matrix_matrix_binary::const_reference reference;
            typedef typename matrix_matrix_binary::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;
# 4557 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
                container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2) {}


        private:

           
            value_type dereference (dense_random_access_iterator_tag) const {
                const self_type &mmb = (*this) ();

                return mmb (index1 (), index2 ());
# 4590 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp"
            }


           
            value_type dereference (packed_random_access_iterator_tag) const {





                return functor_type::apply (it1_.begin (), it1_.end (),
                                        it2_.begin (), it2_.end (), packed_random_access_iterator_tag ());







            }


           
            value_type dereference (sparse_bidirectional_iterator_tag) const {





                return functor_type::apply (it1_.begin (), it1_.end (),
                                        it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());







            }

        public:

           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4654 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4655 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                return dereference (iterator_category ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return (*this) ().find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index1 ();
            }
           
            size_type index2 () const {
                return it2_.index2 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;




                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4726 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4727 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4732 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_expression.hpp" << " at line " << 4733 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:

                        const_iterator11_type it1_;
            const_iterator22_type it2_;




        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

    private:
        expression1_closure_type e1_;
        expression2_closure_type e2_;
    };

    template<class T1, class E1, class T2, class E2>
    struct matrix_matrix_binary_traits {
        typedef unknown_storage_tag storage_category;
        typedef unknown_orientation_tag orientation_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_matrix_binary<E1, E2, matrix_matrix_prod<E1, E2, promote_type> > expression_type;

        typedef expression_type result_type;



    };

    template<class E1, class E2>
   
    typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                         typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2,
          unknown_storage_tag,
          unknown_orientation_tag) {
        typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                                     typename E2::value_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                         typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E1::complexity == 0 && E2::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_4815;
        typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                                     typename E2::value_type, E2>::storage_category storage_category;
        typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                                     typename E2::value_type, E2>::orientation_category orientation_category;
        return prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class E1, class E2>
   
    typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                         typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2,
               unknown_storage_tag,
               unknown_orientation_tag) {
        typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                     typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    template<class E1, class E2>
   
    typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                         typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2) {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((E1::complexity == 0 && E2::complexity == 0) == 0 ? false : true) >)> boost_static_assert_typedef_4843;
        typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                     typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
        typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                                     typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
        return prec_prod (e1, e2, storage_category (), orientation_category ());
    }

    template<class M, class E1, class E2>
   
    M &
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2,
          M &m) {
        return m.assign (prod (e1, e2));
    }

    template<class M, class E1, class E2>
   
    M &
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2,
               M &m) {
        return m.assign (prec_prod (e1, e2));
    }

    template<class M, class E1, class E2>
   
    M
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2) {
        return M (prod (e1, e2));
    }

    template<class M, class E1, class E2>
   
    M
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2) {
        return M (prec_prod (e1, e2));
    }

    template<class E, class F>
    class matrix_scalar_unary:
        public scalar_expression<matrix_scalar_unary<E, F> > {
    public:
        typedef E expression_type;
        typedef F functor_type;
        typedef typename F::result_type value_type;
        typedef typename E::const_closure_type expression_closure_type;


       
        explicit matrix_scalar_unary (const expression_type &e):
            e_ (e) {}

    private:

       
        const expression_closure_type &expression () const {
            return e_;
        }

    public:
       
        operator value_type () const {
            return functor_type::apply (e_);
        }

    private:
        expression_closure_type e_;
    };

    template<class E, class F>
    struct matrix_scalar_unary_traits {
        typedef matrix_scalar_unary<E, F> expression_type;

         typedef expression_type result_type;



    };

    template<class E>
   
    typename matrix_scalar_unary_traits<E, matrix_norm_1<E> >::result_type
    norm_1 (const matrix_expression<E> &e) {
        typedef typename matrix_scalar_unary_traits<E, matrix_norm_1<E> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E>
   
    typename matrix_scalar_unary_traits<E, matrix_norm_frobenius<E> >::result_type
    norm_frobenius (const matrix_expression<E> &e) {
        typedef typename matrix_scalar_unary_traits<E, matrix_norm_frobenius<E> >::expression_type expression_type;
        return expression_type (e ());
    }

    template<class E>
   
    typename matrix_scalar_unary_traits<E, matrix_norm_inf<E> >::result_type
    norm_inf (const matrix_expression<E> &e) {
        typedef typename matrix_scalar_unary_traits<E, matrix_norm_inf<E> >::expression_type expression_type;
        return expression_type (e ());
    }

}}}
# 18 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" 2
# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp"
#define _BOOST_UBLAS_MATRIX_ASSIGN_ 






namespace boost { namespace numeric { namespace ublas {
namespace detail {






    template<class E1, class E2, class S>
   
    bool equals (const matrix_expression<E1> &e1, const matrix_expression<E2> &e2, S epsilon, S min_norm) {
        return norm_inf (e1 - e2) < epsilon *
               std::max<S> (std::max<S> (norm_inf (e1), norm_inf (e2)), min_norm);
    }

    template<class E1, class E2>
   
    bool expression_type_check (const matrix_expression<E1> &e1, const matrix_expression<E2> &e2) {
        typedef typename type_traits<typename promote_traits<typename E1::value_type,
                                     typename E2::value_type>::promote_type>::real_type real_type;
        return equals (e1, e2, (type_traits<real_type>::type_sqrt (std::numeric_limits<real_type>::epsilon ())), (type_traits<real_type>::type_sqrt ( (std::numeric_limits<real_type>::min) ())));
    }


    template<class M, class E, class R>

    void make_conformant (M &m, const matrix_expression<E> &e, row_major_tag, R) {
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 48 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 49 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;

        std::vector<std::pair<size_type, size_type> > index;
        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        typename E::const_iterator1 it1e (e ().begin1 ());
        typename E::const_iterator1 it1e_end (e ().end1 ());
        while (it1 != it1_end && it1e != it1e_end) {
            difference_type compare = it1.index1 () - it1e.index1 ();
            if (compare == 0) {

                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
                typename E::const_iterator2 it2e (it1e.begin ());
                typename E::const_iterator2 it2e_end (it1e.end ());






                if (it2 != it2_end && it2e != it2e_end) {
                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
                    while (true) {
                        difference_type compare = it2_index - it2e_index;
                        if (compare == 0) {
                            ++ it2, ++ it2e;
                            if (it2 != it2_end && it2e != it2e_end) {
                                it2_index = it2.index2 ();
                                it2e_index = it2e.index2 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            increment (it2, it2_end, - compare);
                            if (it2 != it2_end)
                                it2_index = it2.index2 ();
                            else
                                break;
                        } else if (compare > 0) {
                            if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
                                if (*it2e != value_type ())
                                    index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
                            ++ it2e;
                            if (it2e != it2e_end)
                                it2e_index = it2e.index2 ();
                            else
                                break;
                        }
                    }
                }
                while (it2e != it2e_end) {
                    if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
                        if (*it2e != value_type ())
                            index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
                    ++ it2e;
                }
                ++ it1, ++ it1e;
            } else if (compare < 0) {
                increment (it1, it1_end, - compare);
            } else if (compare > 0) {

                typename E::const_iterator2 it2e (it1e.begin ());
                typename E::const_iterator2 it2e_end (it1e.end ());




                while (it2e != it2e_end) {
                    if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
                        if (*it2e != value_type ())
                            index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
                    ++ it2e;
                }
                ++ it1e;
            }
        }
        while (it1e != it1e_end) {

            typename E::const_iterator2 it2e (it1e.begin ());
            typename E::const_iterator2 it2e_end (it1e.end ());




            while (it2e != it2e_end) {
                if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
                    if (*it2e != value_type ())
                        index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
                ++ it2e;
            }
            ++ it1e;
        }

        for (size_type k = 0; k < index.size (); ++ k)
            m (index [k].first, index [k].second) = value_type ();
    }
    template<class M, class E, class R>

    void make_conformant (M &m, const matrix_expression<E> &e, column_major_tag, R) {
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 152 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 153 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        std::vector<std::pair<size_type, size_type> > index;
        typename M::iterator2 it2 (m.begin2 ());
        typename M::iterator2 it2_end (m.end2 ());
        typename E::const_iterator2 it2e (e ().begin2 ());
        typename E::const_iterator2 it2e_end (e ().end2 ());
        while (it2 != it2_end && it2e != it2e_end) {
            difference_type compare = it2.index2 () - it2e.index2 ();
            if (compare == 0) {

                typename M::iterator1 it1 (it2.begin ());
                typename M::iterator1 it1_end (it2.end ());
                typename E::const_iterator1 it1e (it2e.begin ());
                typename E::const_iterator1 it1e_end (it2e.end ());






                if (it1 != it1_end && it1e != it1e_end) {
                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
                    while (true) {
                        difference_type compare = it1_index - it1e_index;
                        if (compare == 0) {
                            ++ it1, ++ it1e;
                            if (it1 != it1_end && it1e != it1e_end) {
                                it1_index = it1.index1 ();
                                it1e_index = it1e.index1 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            increment (it1, it1_end, - compare);
                            if (it1 != it1_end)
                                it1_index = it1.index1 ();
                            else
                                break;
                        } else if (compare > 0) {
                            if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
                                if (*it1e != value_type ())
                                    index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
                            ++ it1e;
                            if (it1e != it1e_end)
                                it1e_index = it1e.index1 ();
                            else
                                break;
                        }
                    }
                }
                while (it1e != it1e_end) {
                    if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
                        if (*it1e != value_type ())
                            index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
                    ++ it1e;
                }
                ++ it2, ++ it2e;
            } else if (compare < 0) {
                increment (it2, it2_end, - compare);
            } else if (compare > 0) {

                typename E::const_iterator1 it1e (it2e.begin ());
                typename E::const_iterator1 it1e_end (it2e.end ());




                while (it1e != it1e_end) {
                    if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
                        if (*it1e != value_type ())
                            index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
                    ++ it1e;
                }
                ++ it2e;
            }
        }
        while (it2e != it2e_end) {

            typename E::const_iterator1 it1e (it2e.begin ());
            typename E::const_iterator1 it1e_end (it2e.end ());




            while (it1e != it1e_end) {
                if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
                    if (*it1e != value_type ())
                        index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
                ++ it1e;
            }
            ++ it2e;
        }

        for (size_type k = 0; k < index.size (); ++ k)
            m (index [k].first, index [k].second) = value_type ();
    }

}



    template<template <class T1, class T2> class F, class M, class T>

    void iterating_matrix_assign_scalar (M &m, const T &t, row_major_tag) {
        typedef F<typename M::iterator2::reference, T> functor_type;
        typedef typename M::difference_type difference_type;
        difference_type size1 (m.size1 ());
        difference_type size2 (m.size2 ());
        typename M::iterator1 it1 (m.begin1 ());
        if (! (size2 == 0 || m.end1 () - it1 == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 265 << ":" << std::endl; std::cerr << "size2 == 0 || m.end1 () - it1 == size1" << std::endl; bad_size ().raise (); };
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());



            if (! (it1.end () - it2 == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 272 << ":" << std::endl; std::cerr << "it1.end () - it2 == size2" << std::endl; bad_size ().raise (); };
            difference_type temp_size2 (size2);

            while (-- temp_size2 >= 0)
                functor_type::apply (*it2, t), ++ it2;



            ++ it1;
        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void iterating_matrix_assign_scalar (M &m, const T &t, column_major_tag) {
        typedef F<typename M::iterator1::reference, T> functor_type;
        typedef typename M::difference_type difference_type;
        difference_type size2 (m.size2 ());
        difference_type size1 (m.size1 ());
        typename M::iterator2 it2 (m.begin2 ());
        if (! (size1 == 0 || m.end2 () - it2 == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 292 << ":" << std::endl; std::cerr << "size1 == 0 || m.end2 () - it2 == size2" << std::endl; bad_size ().raise (); };
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());



            if (! (it2.end () - it1 == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 299 << ":" << std::endl; std::cerr << "it2.end () - it1 == size1" << std::endl; bad_size ().raise (); };
            difference_type temp_size1 (size1);

            while (-- temp_size1 >= 0)
                functor_type::apply (*it1, t), ++ it1;



            ++ it2;
        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void indexing_matrix_assign_scalar (M &m, const T &t, row_major_tag) {
        typedef F<typename M::reference, T> functor_type;
        typedef typename M::size_type size_type;
        size_type size1 (m.size1 ());
        size_type size2 (m.size2 ());
        for (size_type i = 0; i < size1; ++ i) {

            for (size_type j = 0; j < size2; ++ j)
                functor_type::apply (m (i, j), t);




        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void indexing_matrix_assign_scalar (M &m, const T &t, column_major_tag) {
        typedef F<typename M::reference, T> functor_type;
        typedef typename M::size_type size_type;
        size_type size2 (m.size2 ());
        size_type size1 (m.size1 ());
        for (size_type j = 0; j < size2; ++ j) {

            for (size_type i = 0; i < size1; ++ i)
                functor_type::apply (m (i, j), t);




        }
    }


    template<template <class T1, class T2> class F, class M, class T, class C>

    void matrix_assign_scalar (M &m, const T &t, dense_proxy_tag, C) {
        typedef C orientation_category;

        indexing_matrix_assign_scalar<F> (m, t, orientation_category ());
# 366 "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp"
    }

    template<template <class T1, class T2> class F, class M, class T>

    void matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, T> functor_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator1 it1 (m.begin1 ());
        difference_type size1 (m.end1 () - it1);
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());
            difference_type size2 (it1.end () - it2);




            while (-- size2 >= 0)
                functor_type::apply (*it2, t), ++ it2;
            ++ it1;
        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, T> functor_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator2 it2 (m.begin2 ());
        difference_type size2 (m.end2 () - it2);
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());
            difference_type size1 (it2.end () - it1);




            while (-- size1 >= 0)
                functor_type::apply (*it1, t), ++ it1;
            ++ it2;
        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, T> functor_type;
        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        while (it1 != it1_end) {

            typename M::iterator2 it2 (it1.begin ());
            typename M::iterator2 it2_end (it1.end ());




            while (it2 != it2_end)
                functor_type::apply (*it2, t), ++ it2;
            ++ it1;
        }
    }

    template<template <class T1, class T2> class F, class M, class T>

    void matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, T> functor_type;
        typename M::iterator2 it2 (m.begin2 ());
        typename M::iterator2 it2_end (m.end2 ());
        while (it2 != it2_end) {

            typename M::iterator1 it1 (it2.begin ());
            typename M::iterator1 it1_end (it2.end ());




            while (it1 != it1_end)
                functor_type::apply (*it1, t), ++ it1;
            ++ it2;
        }
    }


    template<template <class T1, class T2> class F, class M, class T>
   
    void matrix_assign_scalar (M &m, const T &t) {
        typedef typename M::storage_category storage_category;
        typedef typename M::orientation_category orientation_category;
        matrix_assign_scalar<F> (m, t, storage_category (), orientation_category ());
    }

    template<class SC, bool COMPUTED, class RI1, class RI2>
    struct matrix_assign_traits {
        typedef SC storage_category;
    };

    template<bool COMPUTED>
    struct matrix_assign_traits<dense_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag> {
        typedef packed_tag storage_category;
    };
    template<>
    struct matrix_assign_traits<dense_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_tag storage_category;
    };
    template<>
    struct matrix_assign_traits<dense_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<bool COMPUTED>
    struct matrix_assign_traits<dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag> {
        typedef packed_proxy_tag storage_category;
    };
    template<bool COMPUTED>
    struct matrix_assign_traits<dense_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct matrix_assign_traits<packed_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_tag storage_category;
    };
    template<>
    struct matrix_assign_traits<packed_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<bool COMPUTED>
    struct matrix_assign_traits<packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct matrix_assign_traits<sparse_tag, true, dense_random_access_iterator_tag, dense_random_access_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct matrix_assign_traits<sparse_tag, true, packed_random_access_iterator_tag, packed_random_access_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };
    template<>
    struct matrix_assign_traits<sparse_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };


    template<template <class T1, class T2> class F, class M, class E>

    void iterating_matrix_assign (M &m, const matrix_expression<E> &e, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::value_type> functor_type;
        typedef typename M::difference_type difference_type;
        difference_type size1 (same_impl_ex ((m.size1 ()), (e ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 519));
        difference_type size2 (same_impl_ex ((m.size2 ()), (e ().size2 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 520));
        typename M::iterator1 it1 (m.begin1 ());
        if (! (size2 == 0 || m.end1 () - it1 == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 522 << ":" << std::endl; std::cerr << "size2 == 0 || m.end1 () - it1 == size1" << std::endl; bad_size ().raise (); };
        typename E::const_iterator1 it1e (e ().begin1 ());
        if (! (size2 == 0 || e ().end1 () - it1e == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 524 << ":" << std::endl; std::cerr << "size2 == 0 || e ().end1 () - it1e == size1" << std::endl; bad_size ().raise (); };
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());
            typename E::const_iterator2 it2e (it1e.begin ());




            if (! (it1.end () - it2 == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 533 << ":" << std::endl; std::cerr << "it1.end () - it2 == size2" << std::endl; bad_size ().raise (); };
            if (! (it1e.end () - it2e == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 534 << ":" << std::endl; std::cerr << "it1e.end () - it2e == size2" << std::endl; bad_size ().raise (); };
            difference_type temp_size2 (size2);

            while (-- temp_size2 >= 0)
                functor_type::apply (*it2, *it2e), ++ it2, ++ it2e;



            ++ it1, ++ it1e;
        }
    }

    template<template <class T1, class T2> class F, class M, class E>

    void iterating_matrix_assign (M &m, const matrix_expression<E> &e, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::value_type> functor_type;
        typedef typename M::difference_type difference_type;
        difference_type size2 (same_impl_ex ((m.size2 ()), (e ().size2 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 551));
        difference_type size1 (same_impl_ex ((m.size1 ()), (e ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 552));
        typename M::iterator2 it2 (m.begin2 ());
        if (! (size1 == 0 || m.end2 () - it2 == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 554 << ":" << std::endl; std::cerr << "size1 == 0 || m.end2 () - it2 == size2" << std::endl; bad_size ().raise (); };
        typename E::const_iterator2 it2e (e ().begin2 ());
        if (! (size1 == 0 || e ().end2 () - it2e == size2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 556 << ":" << std::endl; std::cerr << "size1 == 0 || e ().end2 () - it2e == size2" << std::endl; bad_size ().raise (); };
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());
            typename E::const_iterator1 it1e (it2e.begin ());




            if (! (it2.end () - it1 == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 565 << ":" << std::endl; std::cerr << "it2.end () - it1 == size1" << std::endl; bad_size ().raise (); };
            if (! (it2e.end () - it1e == size1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 566 << ":" << std::endl; std::cerr << "it2e.end () - it1e == size1" << std::endl; bad_size ().raise (); };
            difference_type temp_size1 (size1);

            while (-- temp_size1 >= 0)
                functor_type::apply (*it1, *it1e), ++ it1, ++ it1e;



            ++ it2, ++ it2e;
        }
    }

    template<template <class T1, class T2> class F, class M, class E>

    void indexing_matrix_assign (M &m, const matrix_expression<E> &e, row_major_tag) {
        typedef F<typename M::reference, typename E::value_type> functor_type;
        typedef typename M::size_type size_type;
        size_type size1 (same_impl_ex ((m.size1 ()), (e ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 583));
        size_type size2 (same_impl_ex ((m.size2 ()), (e ().size2 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 584));
        for (size_type i = 0; i < size1; ++ i) {

            for (size_type j = 0; j < size2; ++ j)
                functor_type::apply (m (i, j), e () (i, j));




        }
    }

    template<template <class T1, class T2> class F, class M, class E>

    void indexing_matrix_assign (M &m, const matrix_expression<E> &e, column_major_tag) {
        typedef F<typename M::reference, typename E::value_type> functor_type;
        typedef typename M::size_type size_type;
        size_type size2 (same_impl_ex ((m.size2 ()), (e ().size2 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 601));
        size_type size1 (same_impl_ex ((m.size1 ()), (e ().size1 ()), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 602));
        for (size_type j = 0; j < size2; ++ j) {

            for (size_type i = 0; i < size1; ++ i)
                functor_type::apply (m (i, j), e () (i, j));




        }
    }


    template<template <class T1, class T2> class F, class R, class M, class E, class C>

    void matrix_assign (M &m, const matrix_expression<E> &e, dense_proxy_tag, C) {

        typedef C orientation_category;

        indexing_matrix_assign<F> (m, e, orientation_category ());
# 634 "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp"
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, packed_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::value_type> functor_type;

        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 643 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 644 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };

        matrix<value_type, row_major> cm (m.size1 (), m.size2 ());
        indexing_matrix_assign<scalar_assign> (cm, m, row_major_tag ());
        indexing_matrix_assign<F> (cm, e, row_major_tag ());

        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        typename E::const_iterator1 it1e (e ().begin1 ());
        typename E::const_iterator1 it1e_end (e ().end1 ());
        difference_type it1_size (it1_end - it1);
        difference_type it1e_size (it1e_end - it1e);
        difference_type diff1 (0);
        if (it1_size > 0 && it1e_size > 0)
            diff1 = it1.index1 () - it1e.index1 ();
        if (diff1 != 0) {
            difference_type size1 = (std::min) (diff1, it1e_size);
            if (size1 > 0) {
                it1e += size1;
                it1e_size -= size1;
                diff1 -= size1;
            }
            size1 = (std::min) (- diff1, it1_size);
            if (size1 > 0) {
                it1_size -= size1;
                if (!functor_type::computed) {
                    while (-- size1 >= 0) {

                        typename M::iterator2 it2 (it1.begin ());
                        typename M::iterator2 it2_end (it1.end ());




                        difference_type size2 (it2_end - it2);
                        while (-- size2 >= 0)
                            functor_type::apply (*it2, value_type ()), ++ it2;
                        ++ it1;
                    }
                } else {
                    it1 += size1;
                }
                diff1 += size1;
            }
        }
        difference_type size1 ((std::min) (it1_size, it1e_size));
        it1_size -= size1;
        it1e_size -= size1;
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());
            typename M::iterator2 it2_end (it1.end ());
            typename E::const_iterator2 it2e (it1e.begin ());
            typename E::const_iterator2 it2e_end (it1e.end ());






            difference_type it2_size (it2_end - it2);
            difference_type it2e_size (it2e_end - it2e);
            difference_type diff2 (0);
            if (it2_size > 0 && it2e_size > 0) {
                diff2 = it2.index2 () - it2e.index2 ();
                difference_type size2 = (std::min) (diff2, it2e_size);
                if (size2 > 0) {
                    it2e += size2;
                    it2e_size -= size2;
                    diff2 -= size2;
                }
                size2 = (std::min) (- diff2, it2_size);
                if (size2 > 0) {
                    it2_size -= size2;
                    if (!functor_type::computed) {
                        while (-- size2 >= 0)
                            functor_type::apply (*it2, value_type ()), ++ it2;
                    } else {
                        it2 += size2;
                    }
                    diff2 += size2;
                }
            }
            difference_type size2 ((std::min) (it2_size, it2e_size));
            it2_size -= size2;
            it2e_size -= size2;
            while (-- size2 >= 0)
                functor_type::apply (*it2, *it2e), ++ it2, ++ it2e;
            size2 = it2_size;
            if (!functor_type::computed) {
                while (-- size2 >= 0)
                    functor_type::apply (*it2, value_type ()), ++ it2;
            } else {
                it2 += size2;
            }
            ++ it1, ++ it1e;
        }
        size1 = it1_size;
        if (!functor_type::computed) {
            while (-- size1 >= 0) {

                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());




                difference_type size2 (it2_end - it2);
                while (-- size2 >= 0)
                    functor_type::apply (*it2, value_type ()), ++ it2;
                ++ it1;
            }
        } else {
            it1 += size1;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (m, cm))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 761 << ":" << std::endl; std::cerr << "detail::expression_type_check (m, cm)" << std::endl; external_logic ().raise (); };

    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, packed_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::value_type> functor_type;

        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 772 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 773 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };

        matrix<value_type, column_major> cm (m.size1 (), m.size2 ());
        indexing_matrix_assign<scalar_assign> (cm, m, column_major_tag ());
        indexing_matrix_assign<F> (cm, e, column_major_tag ());

        typename M::iterator2 it2 (m.begin2 ());
        typename M::iterator2 it2_end (m.end2 ());
        typename E::const_iterator2 it2e (e ().begin2 ());
        typename E::const_iterator2 it2e_end (e ().end2 ());
        difference_type it2_size (it2_end - it2);
        difference_type it2e_size (it2e_end - it2e);
        difference_type diff2 (0);
        if (it2_size > 0 && it2e_size > 0)
            diff2 = it2.index2 () - it2e.index2 ();
        if (diff2 != 0) {
            difference_type size2 = (std::min) (diff2, it2e_size);
            if (size2 > 0) {
                it2e += size2;
                it2e_size -= size2;
                diff2 -= size2;
            }
            size2 = (std::min) (- diff2, it2_size);
            if (size2 > 0) {
                it2_size -= size2;
                if (!functor_type::computed) {
                    while (-- size2 >= 0) {

                        typename M::iterator1 it1 (it2.begin ());
                        typename M::iterator1 it1_end (it2.end ());




                        difference_type size1 (it1_end - it1);
                        while (-- size1 >= 0)
                            functor_type::apply (*it1, value_type ()), ++ it1;
                        ++ it2;
                    }
                } else {
                    it2 += size2;
                }
                diff2 += size2;
            }
        }
        difference_type size2 ((std::min) (it2_size, it2e_size));
        it2_size -= size2;
        it2e_size -= size2;
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());
            typename M::iterator1 it1_end (it2.end ());
            typename E::const_iterator1 it1e (it2e.begin ());
            typename E::const_iterator1 it1e_end (it2e.end ());






            difference_type it1_size (it1_end - it1);
            difference_type it1e_size (it1e_end - it1e);
            difference_type diff1 (0);
            if (it1_size > 0 && it1e_size > 0) {
                diff1 = it1.index1 () - it1e.index1 ();
                difference_type size1 = (std::min) (diff1, it1e_size);
                if (size1 > 0) {
                    it1e += size1;
                    it1e_size -= size1;
                    diff1 -= size1;
                }
                size1 = (std::min) (- diff1, it1_size);
                if (size1 > 0) {
                    it1_size -= size1;
                    if (!functor_type::computed) {
                        while (-- size1 >= 0)
                            functor_type::apply (*it1, value_type ()), ++ it1;
                    } else {
                        it1 += size1;
                    }
                    diff1 += size1;
                }
            }
            difference_type size1 ((std::min) (it1_size, it1e_size));
            it1_size -= size1;
            it1e_size -= size1;
            while (-- size1 >= 0)
                functor_type::apply (*it1, *it1e), ++ it1, ++ it1e;
            size1 = it1_size;
            if (!functor_type::computed) {
                while (-- size1 >= 0)
                    functor_type::apply (*it1, value_type ()), ++ it1;
            } else {
                it1 += size1;
            }
            ++ it2, ++ it2e;
        }
        size2 = it2_size;
        if (!functor_type::computed) {
            while (-- size2 >= 0) {

                typename M::iterator1 it1 (it2.begin ());
                typename M::iterator1 it1_end (it2.end ());




                difference_type size1 (it1_end - it1);
                while (-- size1 >= 0)
                    functor_type::apply (*it1, value_type ()), ++ it1;
                ++ it2;
            }
        } else {
            it2 += size2;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (m, cm))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 890 << ":" << std::endl; std::cerr << "detail::expression_type_check (m, cm)" << std::endl; external_logic ().raise (); };

    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, sparse_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::value_type> functor_type;

        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!functor_type::computed)) == 0 ? false : true) >)> boost_static_assert_typedef_899;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 900 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 901 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };
        typedef typename M::value_type value_type;


        m.clear ();
        typename E::const_iterator1 it1e (e ().begin1 ());
        typename E::const_iterator1 it1e_end (e ().end1 ());
        while (it1e != it1e_end) {

            typename E::const_iterator2 it2e (it1e.begin ());
            typename E::const_iterator2 it2e_end (it1e.end ());




            while (it2e != it2e_end) {
                value_type t (*it2e);
                if (t != value_type ())
                    m.insert_element (it2e.index1 (), it2e.index2 (), t);
                ++ it2e;
            }
            ++ it1e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, sparse_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::value_type> functor_type;

        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!functor_type::computed)) == 0 ? false : true) >)> boost_static_assert_typedef_931;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 932 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 933 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };
        typedef typename M::value_type value_type;


        m.clear ();
        typename E::const_iterator2 it2e (e ().begin2 ());
        typename E::const_iterator2 it2e_end (e ().end2 ());
        while (it2e != it2e_end) {

            typename E::const_iterator1 it1e (it2e.begin ());
            typename E::const_iterator1 it1e_end (it2e.end ());




            while (it1e != it1e_end) {
                value_type t (*it1e);
                if (t != value_type ())
                    m.insert_element (it1e.index1 (), it1e.index2 (), t);
                ++ it1e;
            }
            ++ it2e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, sparse_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::value_type> functor_type;
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 966 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 967 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };

        matrix<value_type, row_major> cm (m.size1 (), m.size2 ());
        indexing_matrix_assign<scalar_assign> (cm, m, row_major_tag ());
        indexing_matrix_assign<F> (cm, e, row_major_tag ());

        detail::make_conformant (m, e, row_major_tag (), conformant_restrict_type ());

        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        typename E::const_iterator1 it1e (e ().begin1 ());
        typename E::const_iterator1 it1e_end (e ().end1 ());
        while (it1 != it1_end && it1e != it1e_end) {
            difference_type compare = it1.index1 () - it1e.index1 ();
            if (compare == 0) {

                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
                typename E::const_iterator2 it2e (it1e.begin ());
                typename E::const_iterator2 it2e_end (it1e.end ());






                if (it2 != it2_end && it2e != it2e_end) {
                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
                    while (true) {
                        difference_type compare = it2_index - it2e_index;
                        if (compare == 0) {
                            functor_type::apply (*it2, *it2e);
                            ++ it2, ++ it2e;
                            if (it2 != it2_end && it2e != it2e_end) {
                                it2_index = it2.index2 ();
                                it2e_index = it2e.index2 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            if (!functor_type::computed) {
                                functor_type::apply (*it2, value_type ());
                                ++ it2;
                            } else
                                increment (it2, it2_end, - compare);
                            if (it2 != it2_end)
                                it2_index = it2.index2 ();
                            else
                                break;
                        } else if (compare > 0) {
                            increment (it2e, it2e_end, compare);
                            if (it2e != it2e_end)
                                it2e_index = it2e.index2 ();
                            else
                                break;
                        }
                    }
                }
                if (!functor_type::computed) {
                    while (it2 != it2_end) {
                        functor_type::apply (*it2, value_type ());
                        ++ it2;
                    }
                } else {
                    it2 = it2_end;
                }
                ++ it1, ++ it1e;
            } else if (compare < 0) {
                if (!functor_type::computed) {

                    typename M::iterator2 it2 (it1.begin ());
                    typename M::iterator2 it2_end (it1.end ());




                    while (it2 != it2_end) {
                        functor_type::apply (*it2, value_type ());
                        ++ it2;
                    }
                    ++ it1;
                } else {
                    increment (it1, it1_end, - compare);
                }
            } else if (compare > 0) {
                increment (it1e, it1e_end, compare);
            }
        }
        if (!functor_type::computed) {
            while (it1 != it1_end) {

                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());




                while (it2 != it2_end) {
                    functor_type::apply (*it2, value_type ());
                    ++ it2;
                }
                ++ it1;
            }
        } else {
            it1 = it1_end;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (m, cm))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1074 << ":" << std::endl; std::cerr << "detail::expression_type_check (m, cm)" << std::endl; external_logic ().raise (); };

    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_assign (M &m, const matrix_expression<E> &e, sparse_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::value_type> functor_type;
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1086 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1087 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };

        matrix<value_type, column_major> cm (m.size1 (), m.size2 ());
        indexing_matrix_assign<scalar_assign> (cm, m, column_major_tag ());
        indexing_matrix_assign<F> (cm, e, column_major_tag ());

        detail::make_conformant (m, e, column_major_tag (), conformant_restrict_type ());

        typename M::iterator2 it2 (m.begin2 ());
        typename M::iterator2 it2_end (m.end2 ());
        typename E::const_iterator2 it2e (e ().begin2 ());
        typename E::const_iterator2 it2e_end (e ().end2 ());
        while (it2 != it2_end && it2e != it2e_end) {
            difference_type compare = it2.index2 () - it2e.index2 ();
            if (compare == 0) {

                typename M::iterator1 it1 (it2.begin ());
                typename M::iterator1 it1_end (it2.end ());
                typename E::const_iterator1 it1e (it2e.begin ());
                typename E::const_iterator1 it1e_end (it2e.end ());






                if (it1 != it1_end && it1e != it1e_end) {
                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
                    while (true) {
                        difference_type compare = it1_index - it1e_index;
                        if (compare == 0) {
                            functor_type::apply (*it1, *it1e);
                            ++ it1, ++ it1e;
                            if (it1 != it1_end && it1e != it1e_end) {
                                it1_index = it1.index1 ();
                                it1e_index = it1e.index1 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            if (!functor_type::computed) {
                                functor_type::apply (*it1, value_type ());
                                ++ it1;
                            } else
                                increment (it1, it1_end, - compare);
                            if (it1 != it1_end)
                                it1_index = it1.index1 ();
                            else
                                break;
                        } else if (compare > 0) {
                            increment (it1e, it1e_end, compare);
                            if (it1e != it1e_end)
                                it1e_index = it1e.index1 ();
                            else
                                break;
                        }
                    }
                }
                if (!functor_type::computed) {
                    while (it1 != it1_end) {
                        functor_type::apply (*it1, value_type ());
                        ++ it1;
                    }
                } else {
                    it1 = it1_end;
                }
                ++ it2, ++ it2e;
            } else if (compare < 0) {
                if (!functor_type::computed) {

                    typename M::iterator1 it1 (it2.begin ());
                    typename M::iterator1 it1_end (it2.end ());




                    while (it1 != it1_end) {
                        functor_type::apply (*it1, value_type ());
                        ++ it1;
                    }
                    ++ it2;
                } else {
                    increment (it2, it2_end, - compare);
                }
            } else if (compare > 0) {
                increment (it2e, it2e_end, compare);
            }
        }
        if (!functor_type::computed) {
            while (it2 != it2_end) {

                typename M::iterator1 it1 (it2.begin ());
                typename M::iterator1 it1_end (it2.end ());




                while (it1 != it1_end) {
                    functor_type::apply (*it1, value_type ());
                    ++ it1;
                }
                ++ it2;
            }
        } else {
            it2 = it2_end;
        }

        if (! disable_type_check<bool>::value)
            if (! (detail::expression_type_check (m, cm))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1194 << ":" << std::endl; std::cerr << "detail::expression_type_check (m, cm)" << std::endl; external_logic ().raise (); };

    }


    template<template <class T1, class T2> class F, class M, class E>
   
    void matrix_assign (M &m, const matrix_expression<E> &e) {
        typedef typename matrix_assign_traits<typename M::storage_category,
                                              F<typename M::reference, typename E::value_type>::computed,
                                              typename E::const_iterator1::iterator_category,
                                              typename E::const_iterator2::iterator_category>::storage_category storage_category;

        typedef typename boost::mpl::if_<boost::is_same<typename M::orientation_category, unknown_orientation_tag>,
                                          typename E::orientation_category ,
                                          typename M::orientation_category >::type orientation_category;
        typedef basic_full<typename M::size_type> unrestricted;
        matrix_assign<F, unrestricted> (m, e, storage_category (), orientation_category ());
    }
    template<template <class T1, class T2> class F, class R, class M, class E>
   
    void matrix_assign (M &m, const matrix_expression<E> &e) {
        typedef R conformant_restrict_type;
        typedef typename matrix_assign_traits<typename M::storage_category,
                                              F<typename M::reference, typename E::value_type>::computed,
                                              typename E::const_iterator1::iterator_category,
                                              typename E::const_iterator2::iterator_category>::storage_category storage_category;

        typedef typename boost::mpl::if_<boost::is_same<typename M::orientation_category, unknown_orientation_tag>,
                                          typename E::orientation_category ,
                                          typename M::orientation_category >::type orientation_category;
        matrix_assign<F, conformant_restrict_type> (m, e, storage_category (), orientation_category ());
    }

    template<class SC, class RI1, class RI2>
    struct matrix_swap_traits {
        typedef SC storage_category;
    };

    template<>
    struct matrix_swap_traits<dense_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };

    template<>
    struct matrix_swap_traits<packed_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag> {
        typedef sparse_proxy_tag storage_category;
    };


    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, dense_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::reference> functor_type;

        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator1 it1 (m.begin1 ());
        typename E::iterator1 it1e (e ().begin1 ());
        difference_type size1 (same_impl_ex ((m.size1 ()), (size_type (e ().end1 () - it1e)), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1253));
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());
            typename E::iterator2 it2e (it1e.begin ());
            difference_type size2 (same_impl_ex ((m.size2 ()), (size_type (it1e.end () - it2e)), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1258));





            while (-- size2 >= 0)
                functor_type::apply (*it2, *it2e), ++ it2, ++ it2e;
            ++ it1, ++ it1e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, dense_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::reference> functor_type;

        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator2 it2 (m.begin2 ());
        typename E::iterator2 it2e (e ().begin2 ());
        difference_type size2 (same_impl_ex ((m.size2 ()), (size_type (e ().end2 () - it2e)), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1279));
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());
            typename E::iterator1 it1e (it2e.begin ());
            difference_type size1 (same_impl_ex ((m.size1 ()), (size_type (it2e.end () - it1e)), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1284));





            while (-- size1 >= 0)
                functor_type::apply (*it1, *it1e), ++ it1, ++ it1e;
            ++ it2, ++ it2e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, packed_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::reference> functor_type;

        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator1 it1 (m.begin1 ());
        typename E::iterator1 it1e (e ().begin1 ());
        difference_type size1 (same_impl_ex ((m.end1 () - it1), (e ().end1 () - it1e), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1305));
        while (-- size1 >= 0) {

            typename M::iterator2 it2 (it1.begin ());
            typename E::iterator2 it2e (it1e.begin ());
            difference_type size2 (same_impl_ex ((it1.end () - it2), (it1e.end () - it2e), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1310));





            while (-- size2 >= 0)
                functor_type::apply (*it2, *it2e), ++ it2, ++ it2e;
            ++ it1, ++ it1e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, packed_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::reference> functor_type;

        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typename M::iterator2 it2 (m.begin2 ());
        typename E::iterator2 it2e (e ().begin2 ());
        difference_type size2 (same_impl_ex ((m.end2 () - it2), (e ().end2 () - it2e), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1331));
        while (-- size2 >= 0) {

            typename M::iterator1 it1 (it2.begin ());
            typename E::iterator1 it1e (it2e.begin ());
            difference_type size1 (same_impl_ex ((it2.end () - it1), (it2e.end () - it1e), "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp", 1336));





            while (-- size1 >= 0)
                functor_type::apply (*it1, *it1e), ++ it1, ++ it1e;
            ++ it2, ++ it2e;
        }
    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, sparse_proxy_tag, row_major_tag) {
        typedef F<typename M::iterator2::reference, typename E::reference> functor_type;
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1356 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1357 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };

        detail::make_conformant (m, e, row_major_tag (), conformant_restrict_type ());

        detail::make_conformant (e (), m, row_major_tag (), conformant_restrict_type ());

        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        typename E::iterator1 it1e (e ().begin1 ());
        typename E::iterator1 it1e_end (e ().end1 ());
        while (it1 != it1_end && it1e != it1e_end) {
            difference_type compare = it1.index1 () - it1e.index1 ();
            if (compare == 0) {

                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
                typename E::iterator2 it2e (it1e.begin ());
                typename E::iterator2 it2e_end (it1e.end ());






                if (it2 != it2_end && it2e != it2e_end) {
                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
                    while (true) {
                        difference_type compare = it2_index - it2e_index;
                        if (compare == 0) {
                            functor_type::apply (*it2, *it2e);
                            ++ it2, ++ it2e;
                            if (it2 != it2_end && it2e != it2e_end) {
                                it2_index = it2.index2 ();
                                it2e_index = it2e.index2 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            increment (it2, it2_end, - compare);
                            if (it2 != it2_end)
                                it2_index = it2.index2 ();
                            else
                                break;
                        } else if (compare > 0) {
                            increment (it2e, it2e_end, compare);
                            if (it2e != it2e_end)
                                it2e_index = it2e.index2 ();
                            else
                                break;
                        }
                    }
                }

                increment (it2e, it2e_end);
                increment (it2, it2_end);

                ++ it1, ++ it1e;
            } else if (compare < 0) {

                while (it1.index1 () < it1e.index1 ()) {

                    typename M::iterator2 it2 (it1.begin ());
                    typename M::iterator2 it2_end (it1.end ());




                    increment (it2, it2_end);
                    ++ it1;
                }



            } else if (compare > 0) {

                while (it1e.index1 () < it1.index1 ()) {

                    typename E::iterator2 it2e (it1e.begin ());
                    typename E::iterator2 it2e_end (it1e.end ());




                    increment (it2e, it2e_end);
                    ++ it1e;
                }



            }
        }

        while (it1e != it1e_end) {

            typename E::iterator2 it2e (it1e.begin ());
            typename E::iterator2 it2e_end (it1e.end ());




            increment (it2e, it2e_end);
            ++ it1e;
        }
        while (it1 != it1_end) {

            typename M::iterator2 it2 (it1.begin ());
            typename M::iterator2 it2_end (it1.end ());




            increment (it2, it2_end);
            ++ it1;
        }

    }

    template<template <class T1, class T2> class F, class R, class M, class E>

    void matrix_swap (M &m, matrix_expression<E> &e, sparse_proxy_tag, column_major_tag) {
        typedef F<typename M::iterator1::reference, typename E::reference> functor_type;
        typedef R conformant_restrict_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        if (! (m.size1 () == e ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1481 << ":" << std::endl; std::cerr << "m.size1 () == e ().size1 ()" << std::endl; bad_size ().raise (); };
        if (! (m.size2 () == e ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/detail/matrix_assign.hpp" << " at line " << 1482 << ":" << std::endl; std::cerr << "m.size2 () == e ().size2 ()" << std::endl; bad_size ().raise (); };

        detail::make_conformant (m, e, column_major_tag (), conformant_restrict_type ());

        detail::make_conformant (e (), m, column_major_tag (), conformant_restrict_type ());

        typename M::iterator2 it2 (m.begin2 ());
        typename M::iterator2 it2_end (m.end2 ());
        typename E::iterator2 it2e (e ().begin2 ());
        typename E::iterator2 it2e_end (e ().end2 ());
        while (it2 != it2_end && it2e != it2e_end) {
            difference_type compare = it2.index2 () - it2e.index2 ();
            if (compare == 0) {

                typename M::iterator1 it1 (it2.begin ());
                typename M::iterator1 it1_end (it2.end ());
                typename E::iterator1 it1e (it2e.begin ());
                typename E::iterator1 it1e_end (it2e.end ());






                if (it1 != it1_end && it1e != it1e_end) {
                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
                    while (true) {
                        difference_type compare = it1_index - it1e_index;
                        if (compare == 0) {
                            functor_type::apply (*it1, *it1e);
                            ++ it1, ++ it1e;
                            if (it1 != it1_end && it1e != it1e_end) {
                                it1_index = it1.index1 ();
                                it1e_index = it1e.index1 ();
                            } else
                                break;
                        } else if (compare < 0) {
                            increment (it1, it1_end, - compare);
                            if (it1 != it1_end)
                                it1_index = it1.index1 ();
                            else
                                break;
                        } else if (compare > 0) {
                            increment (it1e, it1e_end, compare);
                            if (it1e != it1e_end)
                                it1e_index = it1e.index1 ();
                            else
                                break;
                        }
                    }
                }

                increment (it1e, it1e_end);
                increment (it1, it1_end);

                ++ it2, ++ it2e;
            } else if (compare < 0) {

                while (it2.index2 () < it2e.index2 ()) {

                    typename M::iterator1 it1 (it2.begin ());
                    typename M::iterator1 it1_end (it2.end ());




                    increment (it1, it1_end);
                    ++ it2;
                }



            } else if (compare > 0) {

                while (it2e.index2 () < it2.index2 ()) {

                    typename E::iterator1 it1e (it2e.begin ());
                    typename E::iterator1 it1e_end (it2e.end ());




                    increment (it1e, it1e_end);
                    ++ it2e;
                }



            }
        }

        while (it2e != it2e_end) {

            typename E::iterator1 it1e (it2e.begin ());
            typename E::iterator1 it1e_end (it2e.end ());




            increment (it1e, it1e_end);
            ++ it2e;
        }
        while (it2 != it2_end) {

            typename M::iterator1 it1 (it2.begin ());
            typename M::iterator1 it1_end (it2.end ());




            increment (it1, it1_end);
            ++ it2;
        }

    }


    template<template <class T1, class T2> class F, class M, class E>
   
    void matrix_swap (M &m, matrix_expression<E> &e) {
        typedef typename matrix_swap_traits<typename M::storage_category,
                                            typename E::const_iterator1::iterator_category,
                                            typename E::const_iterator2::iterator_category>::storage_category storage_category;

        typedef typename boost::mpl::if_<boost::is_same<typename M::orientation_category, unknown_orientation_tag>,
                                          typename E::orientation_category ,
                                          typename M::orientation_category >::type orientation_category;
        typedef basic_full<typename M::size_type> unrestricted;
        matrix_swap<F, unrestricted> (m, e, storage_category (), orientation_category ());
    }
    template<template <class T1, class T2> class F, class R, class M, class E>
   
    void matrix_swap (M &m, matrix_expression<E> &e) {
        typedef R conformant_restrict_type;
        typedef typename matrix_swap_traits<typename M::storage_category,
                                            typename E::const_iterator1::iterator_category,
                                            typename E::const_iterator2::iterator_category>::storage_category storage_category;

        typedef typename boost::mpl::if_<boost::is_same<typename M::orientation_category, unknown_orientation_tag>,
                                          typename E::orientation_category ,
                                          typename M::orientation_category >::type orientation_category;
        matrix_swap<F, conformant_restrict_type> (m, e, storage_category (), orientation_category ());
    }

}}}
# 19 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" 2






namespace boost { namespace numeric { namespace ublas {

    namespace detail {
        using namespace boost::numeric::ublas;


        template <class L, class M>
       
        void matrix_resize_preserve (M& m, M& temporary) {
            typedef L layout_type;
            typedef typename M::size_type size_type;
            const size_type msize1 (m.size1 ());
            const size_type msize2 (m.size2 ());
            const size_type size1 (temporary.size1 ());
            const size_type size2 (temporary.size2 ());

            const size_type size1_min = (std::min) (size1, msize1);
            const size_type size2_min = (std::min) (size2, msize2);

            const size_type major_size = layout_type::size_M (size1_min, size2_min);
            const size_type minor_size = layout_type::size_m (size1_min, size2_min);

            for (size_type major = 0; major != major_size; ++major) {
                for (size_type minor = 0; minor != minor_size; ++minor) {

                    const size_type i1 = layout_type::index_M(major, minor);
                    const size_type i2 = layout_type::index_m(major, minor);
                    temporary.data () [layout_type::element (i1, size1, i2, size2)] =
                            m.data() [layout_type::element (i1, msize1, i2, msize2)];
                }
            }
            m.assign_temporary (temporary);
        }
    }



    template<class T, class L, class A>
    class matrix:
        public matrix_container<matrix<T, L, A> > {

        typedef T *pointer;
        typedef L layout_type;
        typedef matrix<T, L, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef A array_type;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef vector<T, A> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef dense_tag storage_category;



        typedef typename L::orientation_category orientation_category;


       
        matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), data_ () {}
       
        matrix (size_type size1, size_type size2):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) {
        }
        matrix (size_type size1, size_type size2, const value_type &init):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) {
        }
       
        matrix (size_type size1, size_type size2, const array_type &data):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ (data) {}
       
        matrix (const matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
        template<class AE>
       
        matrix (const matrix_expression<AE> &ae):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ (layout_type::storage_size (size1_, size2_)) {
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }


       
        const array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


       
        void resize (size_type size1, size_type size2, bool preserve = true) {
            if (preserve) {
                self_type temporary (size1, size2);
                detail::matrix_resize_preserve<layout_type> (*this, temporary);
            }
            else {
                data ().resize (layout_type::storage_size (size1, size2));
                size1_ = size1;
                size2_ = size2;
            }
        }


       
        const_reference operator () (size_type i, size_type j) const {
            return data () [layout_type::element (i, size1_, j, size2_)];
        }
       
        reference at_element (size_type i, size_type j) {
            return data () [layout_type::element (i, size1_, j, size2_)];
        }
       
        reference operator () (size_type i, size_type j) {
            return at_element (i, j);
        }


       
        reference insert_element (size_type i, size_type j, const_reference t) {
            return (at_element (i, j) = t);
        }
        void erase_element (size_type i, size_type j) {
            at_element (i, j) = value_type ();
        }


       
        void clear () {
            std::fill (data ().begin (), data ().end (), value_type ());
        }
# 192 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp"
       
        matrix &operator = (const matrix &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            data () = m.data ();
            return *this;
        }

        template<class C>
       
        matrix &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
       
        matrix &assign_temporary (matrix &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        matrix &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        matrix &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        matrix &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        matrix &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        matrix &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        matrix &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                data ().swap (m.data ());
            }
        }
       
        friend void swap (matrix &m1, matrix &m2) {
            m1.swap (m2);
        }


    private:

        typedef typename A::const_iterator const_subiterator_type;
        typedef typename A::iterator subiterator_type;

    public:






        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {



            return const_iterator1 (*this, data ().begin () + layout_type::address (i, size1_, j, size2_));

        }
       
        iterator1 find1 (int , size_type i, size_type j) {



            return iterator1 (*this, data ().begin () + layout_type::address (i, size1_, j, size2_));

        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {



            return const_iterator2 (*this, data ().begin () + layout_type::address (i, size1_, j, size2_));

        }
       
        iterator2 find2 (int , size_type i, size_type j) {



            return iterator2 (*this, data ().begin () + layout_type::address (i, size1_, j, size2_));

        }



        class const_iterator1:
            public container_const_reference<matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename matrix::value_type value_type;
            typedef typename matrix::difference_type difference_type;
            typedef typename matrix::const_reference reference;
            typedef const typename matrix::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                layout_type::increment_i (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator1 &operator -- () {
                layout_type::decrement_i (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                layout_type::increment_i (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                layout_type::decrement_i (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 393 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return layout_type::distance_i (it_ - it.it_, (*this) ().size1 (), (*this) ().size2 ());
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 400 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 401 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return layout_type::index_i (it_ - m.begin1 ().it_, m.size1 (), m.size2 ());
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return layout_type::index_j (it_ - m.begin1 ().it_, m.size1 (), m.size2 ());
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 465 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 470 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator1;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }


        class iterator1:
            public container_reference<matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename matrix::value_type value_type;
            typedef typename matrix::difference_type difference_type;
            typedef typename matrix::reference reference;
            typedef typename matrix::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), it_ () {}
           
            iterator1 (self_type &m, const subiterator_type &it):
                container_reference<self_type> (m), it_ (it) {}


           
            iterator1 &operator ++ () {
                layout_type::increment_i (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator1 &operator -- () {
                layout_type::decrement_i (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                layout_type::increment_i (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                layout_type::decrement_i (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 535 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return layout_type::distance_i (it_ - it.it_, (*this) ().size1 (), (*this) ().size2 ());
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 542 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 543 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                self_type &m = (*this) ();
                return layout_type::index_i (it_ - m.begin1 ().it_, m.size1 (), m.size2 ());
            }
           
            size_type index2 () const {
                self_type &m = (*this) ();
                return layout_type::index_j (it_ - m.begin1 ().it_, m.size1 (), m.size2 ());
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 607 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 612 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }


        class const_iterator2:
            public container_const_reference<matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename matrix::value_type value_type;
            typedef typename matrix::difference_type difference_type;
            typedef typename matrix::const_reference reference;
            typedef const typename matrix::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                layout_type::increment_j (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator2 &operator -- () {
                layout_type::decrement_j (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                layout_type::increment_j (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                layout_type::decrement_j (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 680 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return layout_type::distance_j (it_ - it.it_, (*this) ().size1 (), (*this) ().size2 ());
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 687 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 688 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return layout_type::index_i (it_ - m.begin2 ().it_, m.size1 (), m.size2 ());
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return layout_type::index_j (it_ - m.begin2 ().it_, m.size1 (), m.size2 ());
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 752 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 757 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator2;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }


        class iterator2:
            public container_reference<matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename matrix::value_type value_type;
            typedef typename matrix::difference_type difference_type;
            typedef typename matrix::reference reference;
            typedef typename matrix::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), it_ () {}
           
            iterator2 (self_type &m, const subiterator_type &it):
                container_reference<self_type> (m), it_ (it) {}


           
            iterator2 &operator ++ () {
                layout_type::increment_j (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator2 &operator -- () {
                layout_type::decrement_j (it_, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                layout_type::increment_j (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                layout_type::decrement_j (it_, n, (*this) ().size1 (), (*this) ().size2 ());
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 822 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return layout_type::distance_j (it_ - it.it_, (*this) ().size1 (), (*this) ().size2 ());
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 829 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 830 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                self_type &m = (*this) ();
                return layout_type::index_i (it_ - m.begin2 ().it_, m.size1 (), m.size2 ());
            }
           
            size_type index2 () const {
                self_type &m = (*this) ();
                return layout_type::index_j (it_ - m.begin2 ().it_, m.size1 (), m.size2 ());
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 894 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 899 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("data",data_);
        }

    private:
        size_type size1_;
        size_type size2_;
        array_type data_;
    };



    template<class T, std::size_t M, std::size_t N, class L>
    class bounded_matrix:
        public matrix<T, L, bounded_array<T, M * N> > {

        typedef matrix<T, L, bounded_array<T, M * N> > matrix_type;
    public:
        typedef typename matrix_type::size_type size_type;
        static const size_type max_size1 = M;
        static const size_type max_size2 = N;


       
        bounded_matrix ():
            matrix_type (M, N) {}
       
        bounded_matrix (size_type size1, size_type size2):
            matrix_type (size1, size2) {}
       
        bounded_matrix (const bounded_matrix &m):
            matrix_type (m) {}
        template<class A2>
       
        bounded_matrix (const matrix<T, L, A2> &m):
            matrix_type (m) {}
        template<class AE>
       
        bounded_matrix (const matrix_expression<AE> &ae):
            matrix_type (ae) {}
       
        ~bounded_matrix () {}
# 1027 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp"
       
        bounded_matrix &operator = (const bounded_matrix &m) {
            matrix_type::operator = (m);
            return *this;
        }

        template<class L2, class A2>
       
        bounded_matrix &operator = (const matrix<T, L2, A2> &m) {
            matrix_type::operator = (m);
            return *this;
        }
        template<class C>
       
        bounded_matrix &operator = (const matrix_container<C> &m) {
            matrix_type::operator = (m);
            return *this;
        }
        template<class AE>
       
        bounded_matrix &operator = (const matrix_expression<AE> &ae) {
            matrix_type::operator = (ae);
            return *this;
        }
    };



    template<class T, class L, class A>
    class vector_of_vector:
        public matrix_container<vector_of_vector<T, L, A> > {

        typedef T *pointer;
        typedef L layout_type;
        typedef vector_of_vector<T, L, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef A array_type;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef vector<T, typename A::value_type> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef dense_tag storage_category;



        typedef typename L::orientation_category orientation_category;


       
        vector_of_vector ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), data_ (1) {}
       
        vector_of_vector (size_type size1, size_type size2):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ (1) {
            resize (size1, size2, true);
        }
       
        vector_of_vector (const vector_of_vector &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
        template<class AE>
       
        vector_of_vector (const matrix_expression<AE> &ae):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ (layout_type::size_M (size1_, size2_) + 1) {
            for (size_type k = 0; k < layout_type::size_M (size1_, size2_); ++ k)
                data ()[k].resize (layout_type::size_m (size1_, size2_));
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }


       
        const array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


       
        void resize (size_type size1, size_type size2, bool preserve = true) {
            size1_ = size1;
            size2_ = size2;
            if (preserve)
                data ().resize (layout_type::size_M (size1, size2) + 1, typename array_type::value_type ());
            else
                data ().resize (layout_type::size_M (size1, size2) + 1);
            for (size_type k = 0; k < layout_type::size_M (size1, size2); ++ k) {
                if (preserve)
                    data () [k].resize (layout_type::size_m (size1, size2), value_type ());
                else
                    data () [k].resize (layout_type::size_m (size1, size2));
            }
        }


       
        const_reference operator () (size_type i, size_type j) const {
            return data () [layout_type::index_M (i, j)] [layout_type::index_m (i, j)];
        }
       
        reference at_element (size_type i, size_type j) {
            return data () [layout_type::index_M (i, j)] [layout_type::index_m (i, j)];
        }
       
        reference operator () (size_type i, size_type j) {
            return at_element (i, j);
        }


       
        reference insert_element (size_type i, size_type j, const_reference t) {
            return (at_element (i, j) = t);
        }
       
        void erase_element (size_type i, size_type j) {
            at_element (i, j) = value_type ();
        }


       
        void clear () {
            for (size_type k = 0; k < layout_type::size_M (size1_, size2_); ++ k)
                std::fill (data () [k].begin (), data () [k].end (), value_type ());
        }


       
        vector_of_vector &operator = (const vector_of_vector &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            data () = m.data ();
            return *this;
        }
       
        vector_of_vector &assign_temporary (vector_of_vector &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        vector_of_vector &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        vector_of_vector &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
        template<class AE>
       
        vector_of_vector &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        vector_of_vector& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        vector_of_vector &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        vector_of_vector &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        vector_of_vector& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        vector_of_vector &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        vector_of_vector &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        vector_of_vector& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        vector_of_vector& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (vector_of_vector &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                data ().swap (m.data ());
            }
        }
       
        friend void swap (vector_of_vector &m1, vector_of_vector &m2) {
            m1.swap (m2);
        }


    private:

        typedef typename A::value_type::const_iterator const_subiterator_type;
        typedef typename A::value_type::iterator subiterator_type;
    public:






        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {



            return const_iterator1 (*this, i, j, data () [layout_type::index_M (i, j)].begin () + layout_type::index_m (i, j));

        }
       
        iterator1 find1 (int , size_type i, size_type j) {



            return iterator1 (*this, i, j, data () [layout_type::index_M (i, j)].begin () + layout_type::index_m (i, j));

        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {



            return const_iterator2 (*this, i, j, data () [layout_type::index_M (i, j)].begin () + layout_type::index_m (i, j));

        }
       
        iterator2 find2 (int , size_type i, size_type j) {



            return iterator2 (*this, i, j, data () [layout_type::index_M (i, j)].begin () + layout_type::index_m (i, j));

        }



        class const_iterator1:
            public container_const_reference<vector_of_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename vector_of_vector::value_type value_type;
            typedef typename vector_of_vector::difference_type difference_type;
            typedef typename vector_of_vector::const_reference reference;
            typedef const typename vector_of_vector::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), i_ (), j_ (), it_ () {}
           
            const_iterator1 (const self_type &m, size_type i, size_type j, const const_subiterator_type &it):
                container_const_reference<self_type> (m), i_ (i), j_ (j), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), i_ (it.i_), j_ (it.j_), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                ++ i_;
                const self_type &m = (*this) ();
                if (layout_type::fast_i ())
                    ++ it_;
                else
                    it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- i_;
                const self_type &m = (*this) ();
                if (layout_type::fast_i ())
                    -- it_;
                else
                    it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                i_ += n;
                const self_type &m = (*this) ();
                it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                i_ -= n;
                const self_type &m = (*this) ();
                it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1389 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1390 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return index1 () - it.index1 ();
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1397 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1398 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return i_;
            }
           
            size_type index2 () const {
                return j_;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1460 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1461 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1466 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1467 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return it_ < it.it_;
            }

        private:
            size_type i_;
            size_type j_;
            const_subiterator_type it_;

            friend class iterator1;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }


        class iterator1:
            public container_reference<vector_of_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename vector_of_vector::value_type value_type;
            typedef typename vector_of_vector::difference_type difference_type;
            typedef typename vector_of_vector::reference reference;
            typedef typename vector_of_vector::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), i_ (), j_ (), it_ () {}
           
            iterator1 (self_type &m, size_type i, size_type j, const subiterator_type &it):
                container_reference<self_type> (m), i_ (i), j_ (j), it_ (it) {}


           
            iterator1 &operator ++ () {
                ++ i_;
                self_type &m = (*this) ();
                if (layout_type::fast_i ())
                    ++ it_;
                else
                    it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            iterator1 &operator -- () {
                -- i_;
                self_type &m = (*this) ();
                if (layout_type::fast_i ())
                    -- it_;
                else
                    it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                i_ += n;
                self_type &m = (*this) ();
                it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                i_ -= n;
                self_type &m = (*this) ();
                it_ = m.find1 (1, i_, j_).it_;
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1548 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1549 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return index1 () - it.index1 ();
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1556 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1557 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return i_;
            }
           
            size_type index2 () const {
                return j_;
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1619 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1620 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1625 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index2 () == it.index2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1626 << ":" << std::endl; std::cerr << "index2 () == it.index2 ()" << std::endl; bad_index ().raise (); };
                return it_ < it.it_;
            }

        private:
            size_type i_;
            size_type j_;
            subiterator_type it_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }


        class const_iterator2:
            public container_const_reference<vector_of_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename vector_of_vector::value_type value_type;
            typedef typename vector_of_vector::difference_type difference_type;
            typedef typename vector_of_vector::const_reference reference;
            typedef const typename vector_of_vector::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), i_ (), j_ (), it_ () {}
           
            const_iterator2 (const self_type &m, size_type i, size_type j, const const_subiterator_type &it):
                container_const_reference<self_type> (m), i_ (i), j_ (j), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), i_ (it.i_), j_ (it.j_), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                ++ j_;
                const self_type &m = (*this) ();
                if (layout_type::fast_j ())
                    ++ it_;
                else
                    it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- j_;
                const self_type &m = (*this) ();
                if (layout_type::fast_j ())
                    -- it_;
                else
                    it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                j_ += n;
                const self_type &m = (*this) ();
                it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                j_ -= n;
                const self_type &m = (*this) ();
                it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1710 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1711 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return index2 () - it.index2 ();
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1718 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1719 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return i_;
            }
           
            size_type index2 () const {
                return j_;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1781 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1782 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1787 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1788 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return it_ < it.it_;
            }

        private:
            size_type i_;
            size_type j_;
            const_subiterator_type it_;

            friend class iterator2;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }


        class iterator2:
            public container_reference<vector_of_vector>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename vector_of_vector::value_type value_type;
            typedef typename vector_of_vector::difference_type difference_type;
            typedef typename vector_of_vector::reference reference;
            typedef typename vector_of_vector::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), i_ (), j_ (), it_ () {}
           
            iterator2 (self_type &m, size_type i, size_type j, const subiterator_type &it):
                container_reference<self_type> (m), i_ (i), j_ (j), it_ (it) {}


           
            iterator2 &operator ++ () {
                ++ j_;
                self_type &m = (*this) ();
                if (layout_type::fast_j ())
                    ++ it_;
                else
                    it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            iterator2 &operator -- () {
                -- j_;
                self_type &m = (*this) ();
                if (layout_type::fast_j ())
                    -- it_;
                else
                    it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                j_ += n;
                self_type &m = (*this) ();
                it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                j_ -= n;
                self_type &m = (*this) ();
                it_ = m.find2 (1, i_, j_).it_;
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1869 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1870 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return index2 () - it.index2 ();
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1877 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1878 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return i_;
            }
           
            size_type index2 () const {
                return j_;
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1940 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1941 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1946 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (index1 () == it.index1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 1947 << ":" << std::endl; std::cerr << "index1 () == it.index1 ()" << std::endl; bad_index ().raise (); };
                return it_ < it.it_;
            }

        private:
            size_type i_;
            size_type j_;
            subiterator_type it_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("data",data_);
        }

    private:
        size_type size1_;
        size_type size2_;
        array_type data_;
    };



    template<class T, class ALLOC>
    class zero_matrix:
        public matrix_container<zero_matrix<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef zero_matrix<T, ALLOC> self_type;
    public:



        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef sparse_tag storage_category;
        typedef unknown_orientation_tag orientation_category;


       
        zero_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0) {}
       
        zero_matrix (size_type size):
            matrix_container<self_type> (),
            size1_ (size), size2_ (size) {}
       
        zero_matrix (size_type size1, size_type size2):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2) {}
       
        zero_matrix (const zero_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_) {}


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }


       
        void resize (size_type size, bool preserve = true) {
            size1_ = size;
            size2_ = size;
        }
       
        void resize (size_type size1, size_type size2, bool = true) {
            size1_ = size1;
            size2_ = size2;
        }


       
        const_reference operator () (size_type , size_type ) const {
            return zero_;
        }


       
        zero_matrix &operator = (const zero_matrix &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            return *this;
        }
       
        zero_matrix &assign_temporary (zero_matrix &m) {
            swap (m);
            return *this;
        }


       
        void swap (zero_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
            }
        }
       
        friend void swap (zero_matrix &m1, zero_matrix &m2) {
            m1.swap (m2);
        }


    public:
        class const_iterator1;
        class const_iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int , size_type , size_type ) const {
            return const_iterator1 (*this);
        }
       
        const_iterator2 find2 (int , size_type , size_type ) const {
            return const_iterator2 (*this);
        }

        class const_iterator1:
            public container_const_reference<zero_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename zero_matrix::value_type value_type;
            typedef typename zero_matrix::difference_type difference_type;
            typedef typename zero_matrix::const_reference reference;
            typedef typename zero_matrix::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> () {}
           
            const_iterator1 (const self_type &m):
                container_const_reference<self_type> (m) {}


           
            const_iterator1 &operator ++ () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2169 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2174 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }


           
            const_reference operator * () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2181 << ":" << std::endl; bad_index ().raise ();;
                return zero_;
            }


           



            const_iterator2 begin () const {
                return const_iterator2 ((*this) ());
            }
           



            const_iterator2 end () const {
                return const_iterator2 ((*this) ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2219 << ":" << std::endl; bad_index ().raise ();;
                return 0;
            }
           
            size_type index2 () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2224 << ":" << std::endl; bad_index ().raise ();;
                return 0;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2238 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                detail::ignore_unused_variable_warning(it);
                return true;
            }
        };

        typedef const_iterator1 iterator1;

       
        const_iterator1 begin1 () const {
            return const_iterator1 (*this);
        }
       
        const_iterator1 end1 () const {
            return const_iterator1 (*this);
        }

        class const_iterator2:
            public container_const_reference<zero_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename zero_matrix::value_type value_type;
            typedef typename zero_matrix::difference_type difference_type;
            typedef typename zero_matrix::const_reference reference;
            typedef typename zero_matrix::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> () {}
           
            const_iterator2 (const self_type &m):
                container_const_reference<self_type> (m) {}


           
            const_iterator2 &operator ++ () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2279 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2284 << ":" << std::endl; bad_index ().raise ();;
                return *this;
            }


           
            const_reference operator * () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2291 << ":" << std::endl; bad_index ().raise ();;
                return zero_;
            }


           



            const_iterator1 begin () const {
                return const_iterator1 ((*this) ());
            }
           



            const_iterator1 end () const {
                return const_iterator1 ((*this) ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2329 << ":" << std::endl; bad_index ().raise ();;
                return 0;
            }
           
            size_type index2 () const {
                std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2334 << ":" << std::endl; bad_index ().raise ();;
                return 0;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2348 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                detail::ignore_unused_variable_warning(it);
                return true;
            }
        };

        typedef const_iterator2 iterator2;

       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
        }

    private:
        size_type size1_;
        size_type size2_;
        static const value_type zero_;
    };

    template<class T, class ALLOC>
    const typename zero_matrix<T, ALLOC>::value_type zero_matrix<T, ALLOC>::zero_ = T( );



    template<class T, class ALLOC>
    class identity_matrix:
        public matrix_container<identity_matrix<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef identity_matrix<T, ALLOC> self_type;
    public:



        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef sparse_tag storage_category;
        typedef unknown_orientation_tag orientation_category;


       
        identity_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), size_common_ (0) {}
       
        identity_matrix (size_type size):
            matrix_container<self_type> (),
            size1_ (size), size2_ (size), size_common_ ((std::min) (size1_, size2_)) {}
       
        identity_matrix (size_type size1, size_type size2):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), size_common_ ((std::min) (size1_, size2_)) {}
       
        identity_matrix (const identity_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), size_common_ ((std::min) (size1_, size2_)) {}


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }


       
        void resize (size_type size, bool preserve = true) {
            size1_ = size;
            size2_ = size;
            size_common_ = ((std::min)(size1_, size2_));
        }
       
        void resize (size_type size1, size_type size2, bool = true) {
            size1_ = size1;
            size2_ = size2;
            size_common_ = ((std::min)(size1_, size2_));
        }


       
        const_reference operator () (size_type i, size_type j) const {
            if (i == j)
                return one_;
            else
                return zero_;
        }


       
        identity_matrix &operator = (const identity_matrix &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            size_common_ = m.size_common_;
            return *this;
        }
       
        identity_matrix &assign_temporary (identity_matrix &m) {
            swap (m);
            return *this;
        }


       
        void swap (identity_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                std::swap (size_common_, m.size_common_);
            }
        }
       
        friend void swap (identity_matrix &m1, identity_matrix &m2) {
            m1.swap (m2);
        }


    private:

        typedef size_type const_subiterator_type;

    public:
        class const_iterator1;
        class const_iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            if (rank == 1) {
                i = (std::max) (i, j);
                i = (std::min) (i, j + 1);
            }
            return const_iterator1 (*this, i);
        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            if (rank == 1) {
                j = (std::max) (j, i);
                j = (std::min) (j, i + 1);
            }
            return const_iterator2 (*this, j);
        }


        class const_iterator1:
            public container_const_reference<identity_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename identity_matrix::value_type value_type;
            typedef typename identity_matrix::difference_type difference_type;
            typedef typename identity_matrix::const_reference reference;
            typedef typename identity_matrix::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}


           
            const_iterator1 &operator ++ () {
                if (! (it_ < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2569 << ":" << std::endl; std::cerr << "it_ < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                ++it_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                if (! (it_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2575 << ":" << std::endl; std::cerr << "it_ > 0" << std::endl; bad_index ().raise (); };
                --it_;
                return *this;
            }


           
            const_reference operator * () const {
                return one_;
            }


           



            const_iterator2 begin () const {
                return const_iterator2 ((*this) (), it_);
            }
           



            const_iterator2 end () const {
                return const_iterator2 ((*this) (), it_ + 1);
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it_;
            }
           
            size_type index2 () const {
                return it_;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2638 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

        typedef const_iterator1 iterator1;

       
        const_iterator1 begin1 () const {
            return const_iterator1 (*this, 0);
        }
       
        const_iterator1 end1 () const {
            return const_iterator1 (*this, size_common_);
        }

        class const_iterator2:
            public container_const_reference<identity_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename identity_matrix::value_type value_type;
            typedef typename identity_matrix::difference_type difference_type;
            typedef typename identity_matrix::const_reference reference;
            typedef typename identity_matrix::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}


           
            const_iterator2 &operator ++ () {
                if (! (it_ < (*this) ().size_common_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2681 << ":" << std::endl; std::cerr << "it_ < (*this) ().size_common_" << std::endl; bad_index ().raise (); };
                ++it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                if (! (it_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2687 << ":" << std::endl; std::cerr << "it_ > 0" << std::endl; bad_index ().raise (); };
                --it_;
                return *this;
            }


           
            const_reference operator * () const {
                return one_;
            }


           



            const_iterator1 begin () const {
                return const_iterator1 ((*this) (), it_);
            }
           



            const_iterator1 end () const {
                return const_iterator1 ((*this) (), it_ + 1);
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it_;
            }
           
            size_type index2 () const {
                return it_;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2750 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

        typedef const_iterator2 iterator2;

       
        const_iterator2 begin2 () const {
            return const_iterator2 (*this, 0);
        }
       
        const_iterator2 end2 () const {
            return const_iterator2 (*this, size_common_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
                size_common_ = ((std::min)(size1_, size2_));
            }
        }

    private:
        size_type size1_;
        size_type size2_;
        size_type size_common_;
        static const value_type zero_;
        static const value_type one_;
    };

    template<class T, class ALLOC>
    const typename identity_matrix<T, ALLOC>::value_type identity_matrix<T, ALLOC>::zero_ = T( );
    template<class T, class ALLOC>
    const typename identity_matrix<T, ALLOC>::value_type identity_matrix<T, ALLOC>::one_ (1);



    template<class T, class ALLOC>
    class scalar_matrix:
        public matrix_container<scalar_matrix<T, ALLOC> > {

        typedef const T *const_pointer;
        typedef scalar_matrix<T, ALLOC> self_type;
    public:



        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef dense_tag storage_category;
        typedef unknown_orientation_tag orientation_category;


       
        scalar_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), value_ () {}
       
        scalar_matrix (size_type size1, size_type size2, const value_type &value = value_type(1)):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), value_ (value) {}
       
        scalar_matrix (const scalar_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), value_ (m.value_) {}


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }


       
        void resize (size_type size1, size_type size2, bool = true) {
            size1_ = size1;
            size2_ = size2;
        }


       
        const_reference operator () (size_type , size_type ) const {
            return value_;
        }


       
        scalar_matrix &operator = (const scalar_matrix &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            value_ = m.value_;
            return *this;
        }
       
        scalar_matrix &assign_temporary (scalar_matrix &m) {
            swap (m);
            return *this;
        }


       
        void swap (scalar_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                std::swap (value_, m.value_);
            }
        }
       
        friend void swap (scalar_matrix &m1, scalar_matrix &m2) {
            m1.swap (m2);
        }


    private:

        typedef size_type const_subiterator_type;

    public:






        class const_iterator1;
        class const_iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {
            return const_iterator1 (*this, i, j);
        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {
            return const_iterator2 (*this, i, j);
        }



        class const_iterator1:
            public container_const_reference<scalar_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename scalar_matrix::value_type value_type;
            typedef typename scalar_matrix::difference_type difference_type;
            typedef typename scalar_matrix::const_reference reference;
            typedef typename scalar_matrix::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<scalar_matrix> (), it1_ (), it2_ () {}
           
            const_iterator1 (const scalar_matrix &m, const const_subiterator_type &it1, const const_subiterator_type &it2):
                container_const_reference<scalar_matrix> (m), it1_ (it1), it2_ (it2) {}


           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2984 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2985 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2992 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 2993 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return (*this) () (index1 (), index2 ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                const scalar_matrix &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const scalar_matrix &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_;
            }
           
            size_type index2 () const {
                return it2_;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<scalar_matrix>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3056 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3057 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3062 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3063 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            const_subiterator_type it1_;
            const_subiterator_type it2_;
        };

        typedef const_iterator1 iterator1;


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }


        class const_iterator2:
            public container_const_reference<scalar_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename scalar_matrix::value_type value_type;
            typedef typename scalar_matrix::difference_type difference_type;
            typedef typename scalar_matrix::const_reference reference;
            typedef typename scalar_matrix::const_pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<scalar_matrix> (), it1_ (), it2_ () {}
           
            const_iterator2 (const scalar_matrix &m, const const_subiterator_type &it1, const const_subiterator_type &it2):
                container_const_reference<scalar_matrix> (m), it1_ (it1), it2_ (it2) {}


           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3129 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3130 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3137 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3138 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return (*this) () (index1 (), index2 ());
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                const scalar_matrix &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const scalar_matrix &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_;
            }
           
            size_type index2 () const {
                return it2_;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<scalar_matrix>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3201 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3202 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3207 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3208 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            const_subiterator_type it1_;
            const_subiterator_type it2_;
        };

        typedef const_iterator2 iterator2;


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }

            ar & serialization::make_nvp("value", value_);
        }

    private:
        size_type size1_;
        size_type size2_;
        value_type value_;
    };



    template<class T, std::size_t N, std::size_t M>
    class c_matrix:
        public matrix_container<c_matrix<T, N, M> > {

        typedef c_matrix<T, N, M> self_type;
    public:



        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T &const_reference;
        typedef T &reference;
        typedef const T *const_pointer;
        typedef T *pointer;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef c_vector<T, N * M> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef dense_tag storage_category;



        typedef row_major_tag orientation_category;


       
        c_matrix ():
            size1_ (N), size2_ (M) {
        }
       
        c_matrix (size_type size1, size_type size2):
            size1_ (size1), size2_ (size2) {
            if (size1_ > N || size2_ > M)
                bad_size ().raise ();
        }
       
        c_matrix (const c_matrix &m):
            size1_ (m.size1_), size2_ (m.size2_) {
            if (size1_ > N || size2_ > M)
                bad_size ().raise ();
            assign(m);
        }
        template<class AE>
       
        c_matrix (const matrix_expression<AE> &ae):
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()) {
            if (size1_ > N || size2_ > M)
                bad_size ().raise ();
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }
       
        const_pointer data () const {
            return reinterpret_cast<const_pointer> (data_);
        }
       
        pointer data () {
            return reinterpret_cast<pointer> (data_);
        }


       
        void resize (size_type size1, size_type size2, bool preserve = true) {
            if (size1 > N || size2 > M)
                bad_size ().raise ();
            if (preserve) {
                self_type temporary (size1, size2);

                const size_type size1_min = (std::min) (size1, size1_);
                const size_type size2_min = (std::min) (size2, size2_);
                for (size_type i = 0; i != size1_min; ++i) {
                    for (size_type j = 0; j != size2_min; ++j) {
                        temporary.data_[i][j] = data_[i][j];
                    }
                }
                assign_temporary (temporary);
            }
            else {
                size1_ = size1;
                size2_ = size2;
            }
        }


       
        const_reference operator () (size_type i, size_type j) const {
            if (! (i < size1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3376 << ":" << std::endl; std::cerr << "i < size1_" << std::endl; bad_index ().raise (); };
            if (! (j < size2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3377 << ":" << std::endl; std::cerr << "j < size2_" << std::endl; bad_index ().raise (); };
            return data_ [i] [j];
        }
       
        reference at_element (size_type i, size_type j) {
            if (! (i < size1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3382 << ":" << std::endl; std::cerr << "i < size1_" << std::endl; bad_index ().raise (); };
            if (! (j < size2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3383 << ":" << std::endl; std::cerr << "j < size2_" << std::endl; bad_index ().raise (); };
            return data_ [i] [j];
        }
       
        reference operator () (size_type i, size_type j) {
            return at_element (i, j);
        }


       
        reference insert_element (size_type i, size_type j, const_reference t) {
            return (at_element (i, j) = t);
        }


       
        void clear () {
            for (size_type i = 0; i < size1_; ++ i)
                std::fill (data_ [i], data_ [i] + size2_, value_type ());
        }
# 3414 "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp"
       
        c_matrix &operator = (const c_matrix &m) {
            size1_ = m.size1_;
            size2_ = m.size2_;
            for (size_type i = 0; i < m.size1_; ++ i)
                std::copy (m.data_ [i], m.data_ [i] + m.size2_, data_ [i]);
            return *this;
        }

        template<class C>
       
        c_matrix &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
       
        c_matrix &assign_temporary (c_matrix &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        c_matrix &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        c_matrix &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        c_matrix& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        c_matrix &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        c_matrix &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        c_matrix& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        c_matrix &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        c_matrix &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        c_matrix& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        c_matrix& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (c_matrix &m) {
            if (this != &m) {
                if (! (size1_ == m.size1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3500 << ":" << std::endl; std::cerr << "size1_ == m.size1_" << std::endl; bad_size ().raise (); };
                if (! (size2_ == m.size2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3501 << ":" << std::endl; std::cerr << "size2_ == m.size2_" << std::endl; bad_size ().raise (); };
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                for (size_type i = 0; i < size1_; ++ i)
                    std::swap_ranges (data_ [i], data_ [i] + size2_, m.data_ [i]);
            }
        }
       
        friend void swap (c_matrix &m1, c_matrix &m2) {
            m1.swap (m2);
        }


    private:

        typedef const_pointer const_subiterator_type;
        typedef pointer subiterator_type;

    public:






        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {



            return const_iterator1 (*this, &data_ [i] [j]);

        }
       
        iterator1 find1 (int rank, size_type i, size_type j) {



            return iterator1 (*this, &data_ [i] [j]);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {



            return const_iterator2 (*this, &data_ [i] [j]);

        }
       
        iterator2 find2 (int rank, size_type i, size_type j) {



            return iterator2 (*this, &data_ [i] [j]);

        }



        class const_iterator1:
            public container_const_reference<c_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename c_matrix::difference_type difference_type;
            typedef typename c_matrix::value_type value_type;
            typedef typename c_matrix::const_reference reference;
            typedef typename c_matrix::const_pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                it_ += M;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                it_ -= M;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it_ += n * M;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it_ -= n * M;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3619 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return (it_ - it.it_) / M;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3626 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3627 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin1 ().it_) / M;
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin1 ().it_) % M;
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3691 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3696 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator1;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }


        class iterator1:
            public container_reference<c_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator1, value_type> {
        public:

            typedef typename c_matrix::difference_type difference_type;
            typedef typename c_matrix::value_type value_type;
            typedef typename c_matrix::reference reference;
            typedef typename c_matrix::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), it_ () {}
           
            iterator1 (self_type &m, const subiterator_type &it):
                container_reference<self_type> (m), it_ (it) {}


           
            iterator1 &operator ++ () {
                it_ += M;
                return *this;
            }
           
            iterator1 &operator -- () {
                it_ -= M;
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                it_ += n * M;
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                it_ -= n * M;
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3762 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return (it_ - it.it_) / M;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3769 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3770 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin1 ().it_) / M;
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin1 ().it_) % M;
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3834 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3839 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }


        class const_iterator2:
            public container_const_reference<c_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename c_matrix::difference_type difference_type;
            typedef typename c_matrix::value_type value_type;
            typedef typename c_matrix::const_reference reference;
            typedef typename c_matrix::const_reference pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &m, const const_subiterator_type &it):
                container_const_reference<self_type> (m), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3907 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3914 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3915 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin2 ().it_) / M;
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin2 ().it_) % M;
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3979 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 3984 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;

            friend class iterator2;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }


        class iterator2:
            public container_reference<c_matrix>,
            public random_access_iterator_base<dense_random_access_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename c_matrix::difference_type difference_type;
            typedef typename c_matrix::value_type value_type;
            typedef typename c_matrix::reference reference;
            typedef typename c_matrix::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), it_ () {}
           
            iterator2 (self_type &m, const subiterator_type &it):
                container_reference<self_type> (m), it_ (it) {}


           
            iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 4049 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 4056 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 4057 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin2 ().it_) / M;
            }
           
            size_type index2 () const {
                const self_type &m = (*this) ();
                return (it_ - m.begin2 ().it_) % M;
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 4121 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix.hpp" << " at line " << 4126 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){



            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);


            ar & serialization::make_nvp("size1",s1)
               & serialization::make_nvp("size2",s2);


            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }

            ar & serialization::make_array(data_, N);
        }

    private:
        size_type size1_;
        size_type size2_;
        value_type data_ [N] [M];
    };

}}}
# 8 "/home/preben/working/CRTPlanner/Constraint.hpp" 2

namespace rw { namespace dynamics {

 template <typename T = double>
 class Constraint {
  public:
   Constraint() {};
   virtual ~Constraint() {};

   std::vector<unsigned int>& getDependencies() { return _depends; }
   const std::vector<unsigned int>& getDependencies() const { return _depends; }




   virtual T evaluate(const boost::numeric::ublas::vector<T>& q) const = 0;
   virtual T dG(unsigned int variable, const boost::numeric::ublas::vector<T>& q) const = 0;
   virtual T ddG(unsigned int variable1, unsigned int variable2, const boost::numeric::ublas::vector<T>& q) const = 0;

  protected:
   std::vector<unsigned int> _depends;
   std::vector<T> _coeffs;
 };

} }
# 7 "/home/preben/working/CRTPlanner/MechSystem.hpp" 2






# 1 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp"
#define _BOOST_UBLAS_MATRIX_SPARSE_ 

# 1 "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp"
#define _BOOST_UBLAS_VECTOR_SPARSE_ 

# 1 "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp"
#define _BOOST_UBLAS_STORAGE_SPARSE_ 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 1 3
# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 3
#define _GLIBCXX_MAP 1

       
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tree.h" 1 3
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tree.h" 3
#define _STL_TREE_H 1






namespace std __attribute__ ((__visibility__ ("default"))) {
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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_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;

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef _Rb_tree_node<_Val>* _Link_type;
      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      _Node_allocator&
      _M_get_Node_allocator()
      { return *static_cast<_Node_allocator*>(&this->_M_impl); }

      const _Node_allocator&
      _M_get_Node_allocator() const
      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return allocator_type(_M_get_Node_allocator()); }

    protected:
      _Link_type
      _M_get_node()
      { return _M_impl._Node_allocator::allocate(1); }

      void
      _M_put_node(_Link_type __p)
      { _M_impl._Node_allocator::deallocate(__p, 1); }


      _Link_type
      _M_create_node(const value_type& __x)
      {
 _Link_type __tmp = _M_get_node();
 try
   { get_allocator().construct(&__tmp->_M_value_field, __x); }
 catch(...)
   {
     _M_put_node(__tmp);
     throw;
   }
 return __tmp;
      }

      void
      _M_destroy_node(_Link_type __p)
      {
 get_allocator().destroy(&__p->_M_value_field);
 _M_put_node(__p);
      }
# 413 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tree.h" 3
      _Link_type
      _M_clone_node(_Const_Link_type __x)
      {
 _Link_type __tmp = _M_create_node(__x->_M_value_field);
 __tmp->_M_color = __x->_M_color;
 __tmp->_M_left = 0;
 __tmp->_M_right = 0;
 return __tmp;
      }

    protected:
      template<typename _Key_compare,
        bool _Is_pod_comparator = __is_pod(_Key_compare)>
        struct _Rb_tree_impl : public _Node_allocator
        {
   _Key_compare _M_key_compare;
   _Rb_tree_node_base _M_header;
   size_type _M_node_count;

   _Rb_tree_impl()
   : _Node_allocator(), _M_key_compare(), _M_header(),
     _M_node_count(0)
   { _M_initialize(); }

   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
     _M_node_count(0)
   { _M_initialize(); }

 private:
   void
   _M_initialize()
   {
     this->_M_header._M_color = _S_red;
     this->_M_header._M_parent = 0;
     this->_M_header._M_left = &this->_M_header;
     this->_M_header._M_right = &this->_M_header;
   }
 };

      _Rb_tree_impl<_Compare> _M_impl;

    protected:
      _Base_ptr&
      _M_root()
      { return this->_M_impl._M_header._M_parent; }

      _Const_Base_ptr
      _M_root() const
      { return this->_M_impl._M_header._M_parent; }

      _Base_ptr&
      _M_leftmost()
      { return this->_M_impl._M_header._M_left; }

      _Const_Base_ptr
      _M_leftmost() const
      { return this->_M_impl._M_header._M_left; }

      _Base_ptr&
      _M_rightmost()
      { return this->_M_impl._M_header._M_right; }

      _Const_Base_ptr
      _M_rightmost() const
      { return this->_M_impl._M_header._M_right; }

      _Link_type
      _M_begin()
      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

      _Const_Link_type
      _M_begin() const
      {
 return static_cast<_Const_Link_type>
   (this->_M_impl._M_header._M_parent);
      }

      _Link_type
      _M_end()
      { return static_cast<_Link_type>(&this->_M_impl._M_header); }

      _Const_Link_type
      _M_end() const
      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }

      static const_reference
      _S_value(_Const_Link_type __x)
      { return __x->_M_value_field; }

      static const _Key&
      _S_key(_Const_Link_type __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Link_type
      _S_left(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_left); }

      static _Const_Link_type
      _S_left(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_left); }

      static _Link_type
      _S_right(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_right); }

      static _Const_Link_type
      _S_right(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_right); }

      static const_reference
      _S_value(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }

      static const _Key&
      _S_key(_Const_Base_ptr __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Base_ptr
      _S_minimum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Const_Base_ptr
      _S_minimum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Base_ptr
      _S_maximum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

      static _Const_Base_ptr
      _S_maximum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type> iterator;
      typedef _Rb_tree_const_iterator<value_type> const_iterator;

      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    private:
      iterator
      _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,
   const value_type& __v);



      iterator
      _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);

      iterator
      _M_insert_equal_lower(const value_type& __x);

      _Link_type
      _M_copy(_Const_Link_type __x, _Link_type __p);

      void
      _M_erase(_Link_type __x);

      iterator
      _M_lower_bound(_Link_type __x, _Link_type __y,
       const _Key& __k);

      const_iterator
      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
       const _Key& __k) const;

      iterator
      _M_upper_bound(_Link_type __x, _Link_type __y,
       const _Key& __k);

      const_iterator
      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
       const _Key& __k) const;

    public:

      _Rb_tree() { }

      _Rb_tree(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_impl(__comp, __a) { }

      _Rb_tree(const _Rb_tree& __x)
      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
      {
 if (__x._M_root() != 0)
   {
     _M_root() = _M_copy(__x._M_begin(), _M_end());
     _M_leftmost() = _S_minimum(_M_root());
     _M_rightmost() = _S_maximum(_M_root());
     _M_impl._M_node_count = __x._M_impl._M_node_count;
   }
      }





      ~_Rb_tree()
      { _M_erase(_M_begin()); }

      _Rb_tree&
      operator=(const _Rb_tree& __x);


      _Compare
      key_comp() const
      { return _M_impl._M_key_compare; }

      iterator
      begin()
      {
 return iterator(static_cast<_Link_type>
   (this->_M_impl._M_header._M_left));
      }

      const_iterator
      begin() const
      {
 return const_iterator(static_cast<_Const_Link_type>
         (this->_M_impl._M_header._M_left));
      }

      iterator
      end()
      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }

      const_iterator
      end() const
      {
 return const_iterator(static_cast<_Const_Link_type>
         (&this->_M_impl._M_header));
      }

      reverse_iterator
      rbegin()
      { return reverse_iterator(end()); }

      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(end()); }

      reverse_iterator
      rend()
      { return reverse_iterator(begin()); }

      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(begin()); }

      bool
      empty() const
      { return _M_impl._M_node_count == 0; }

      size_type
      size() const
      { return _M_impl._M_node_count; }

      size_type
      max_size() const
      { return _M_get_Node_allocator().max_size(); }

      void



      swap(_Rb_tree& __t);



      pair<iterator, bool>
      _M_insert_unique(const value_type& __x);

      iterator
      _M_insert_equal(const value_type& __x);

      iterator
      _M_insert_unique_(const_iterator __position, const value_type& __x);

      iterator
      _M_insert_equal_(const_iterator __position, const value_type& __x);

      template<typename _InputIterator>
        void
        _M_insert_unique(_InputIterator __first, _InputIterator __last);

      template<typename _InputIterator>
        void
        _M_insert_equal(_InputIterator __first, _InputIterator __last);

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

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      iterator
      lower_bound(const key_type& __k)
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      lower_bound(const key_type& __k) const
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      iterator
      upper_bound(const key_type& __k)
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      upper_bound(const key_type& __k) const
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      pair<iterator, iterator>
      equal_range(const key_type& __k);

      pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;


      bool
      __rb_verify() const;
    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return __x.size() == __y.size()
      && std::equal(__x.begin(), __x.end(), __y.begin());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x == __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return __y < __x; }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__y < __x); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x < __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 849 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_tree.h" 3
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
    {
      if (this != &__x)
 {

   clear();
   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
   if (__x._M_root() != 0)
     {
       _M_root() = _M_copy(__x._M_begin(), _M_end());
       _M_leftmost() = _S_minimum(_M_root());
       _M_rightmost() = _S_maximum(_M_root());
       _M_impl._M_node_count = __x._M_impl._M_node_count;
     }
 }
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || _M_impl._M_key_compare(_KeyOfValue()(__v),
            _S_key(__p)));

      _Link_type __z = _M_create_node(__v);

      _Rb_tree_insert_and_rebalance(__insert_left, __z,
        const_cast<_Base_ptr>(__p),
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _KeyOfValue()(__v)));

      _Link_type __z = _M_create_node(__v);

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_lower(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower(__x, __y, __v);
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
    _M_copy(_Const_Link_type __x, _Link_type __p)
    {

      _Link_type __top = _M_clone_node(__x);
      __top->_M_parent = __p;

      try
 {
   if (__x->_M_right)
     __top->_M_right = _M_copy(_S_right(__x), __top);
   __p = __top;
   __x = _S_left(__x);

   while (__x != 0)
     {
       _Link_type __y = _M_clone_node(__x);
       __p->_M_left = __y;
       __y->_M_parent = __p;
       if (__x->_M_right)
  __y->_M_right = _M_copy(_S_right(__x), __y);
       __p = __y;
       __x = _S_left(__x);
     }
 }
      catch(...)
 {
   _M_erase(__top);
   throw;
 }
      return __top;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase(_Link_type __x)
    {

      while (__x != 0)
 {
   _M_erase(_S_right(__x));
   _Link_type __y = _S_left(__x);
   _M_destroy_node(__x);
   __x = __y;
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Link_type __x, _Link_type __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Link_type __x, _Link_type __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Link_type __xu(__x), __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<iterator,
            iterator>(_M_lower_bound(__x, __y, __k),
        _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<iterator, iterator>(iterator(__y),
          iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k) const
    {
      _Const_Link_type __x = _M_begin();
      _Const_Link_type __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Const_Link_type __xu(__x), __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<const_iterator,
            const_iterator>(_M_lower_bound(__x, __y, __k),
       _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<const_iterator, const_iterator>(const_iterator(__y),
        const_iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::



    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)

    {
      if (_M_root() == 0)
 {
   if (__t._M_root() != 0)
     {
       _M_root() = __t._M_root();
       _M_leftmost() = __t._M_leftmost();
       _M_rightmost() = __t._M_rightmost();
       _M_root()->_M_parent = _M_end();

       __t._M_root() = 0;
       __t._M_leftmost() = __t._M_end();
       __t._M_rightmost() = __t._M_end();
     }
 }
      else if (__t._M_root() == 0)
 {
   __t._M_root() = _M_root();
   __t._M_leftmost() = _M_leftmost();
   __t._M_rightmost() = _M_rightmost();
   __t._M_root()->_M_parent = __t._M_end();

   _M_root() = 0;
   _M_leftmost() = _M_end();
   _M_rightmost() = _M_end();
 }
      else
 {
   std::swap(_M_root(),__t._M_root());
   std::swap(_M_leftmost(),__t._M_leftmost());
   std::swap(_M_rightmost(),__t._M_rightmost());

   _M_root()->_M_parent = _M_end();
   __t._M_root()->_M_parent = __t._M_end();
 }

      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);



      std::__alloc_swap<_Node_allocator>::
 _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator, bool>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_unique(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 {
   if (__j == begin())
     return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
   else
     --__j;
 }
      if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
 return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
      return pair<iterator, bool>(__j, false);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _M_insert_(__x, __y, __v);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_unique_(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
     _KeyOfValue()(__v)))
     return _M_insert_(0, _M_rightmost(), __v);
   else
     return _M_insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
          _S_key(__position._M_node)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
       _KeyOfValue()(__v)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert_(0, __before._M_node, __v);
       else
  return _M_insert_(__position._M_node,
      __position._M_node, __v);
     }
   else
     return _M_insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
          _KeyOfValue()(__v)))
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert_(0, _M_rightmost(), __v);
   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key((++__after)._M_node)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert_(0, __position._M_node, __v);
       else
  return _M_insert_(__after._M_node, __after._M_node, __v);
     }
   else
     return _M_insert_unique(__v).first;
 }
      else

 return iterator(static_cast<_Link_type>
   (const_cast<_Base_ptr>(__position._M_node)));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
      _S_key(_M_rightmost())))
     return _M_insert_(0, _M_rightmost(), __v);
   else
     return _M_insert_equal(__v);
 }
      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
           _KeyOfValue()(__v)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
        _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert_(0, __before._M_node, __v);
       else
  return _M_insert_(__position._M_node,
      __position._M_node, __v);
     }
   else
     return _M_insert_equal(__v);
 }
      else
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert_(0, _M_rightmost(), __v);
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
        _KeyOfValue()(__v)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert_(0, __position._M_node, __v);
       else
  return _M_insert_(__after._M_node, __after._M_node, __v);
     }
   else
     return _M_insert_equal_lower(__v);
 }
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      _M_insert_unique(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first);
      }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      _M_insert_equal(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    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));
      _M_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));
      _M_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);
      const size_type __old_size = size();
      erase(__p.first, __p.second);
      return __old_size - size();
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(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)
    {
      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k) const
    {
      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    count(const _Key& __k) const
    {
      pair<const_iterator, const_iterator> __p = equal_range(__k);
      const size_type __n = std::distance(__p.first, __p.second);
      return __n;
    }

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

}
# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
#define _STL_MAP_H 1





namespace std __attribute__ ((__visibility__ ("default"))) {
# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class map
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class map<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename _Alloc::template rebind<value_type>::other
        _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;


      _Rep_type _M_t;

    public:


      typedef typename _Pair_alloc_type::pointer pointer;
      typedef typename _Pair_alloc_type::const_pointer const_pointer;
      typedef typename _Pair_alloc_type::reference reference;
      typedef typename _Pair_alloc_type::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;







      map()
      : _M_t() { }






      explicit
      map(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      map(const map& __x)
      : _M_t(__x._M_t) { }
# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_unique(__first, __last); }
# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t._M_insert_unique(__first, __last); }
# 250 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      map&
      operator=(const map& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 295 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }







      iterator
      begin()
      { return _M_t.begin(); }






      const_iterator
      begin() const
      { return _M_t.begin(); }






      iterator
      end()
      { return _M_t.end(); }






      const_iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin()
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend()
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const
      { return _M_t.rend(); }
# 414 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      mapped_type&
      operator[](const key_type& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))
          __i = insert(__i, value_type(__k, mapped_type()));
 return (*__i).second;
      }
# 463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      mapped_type&
      at(const key_type& __k)
      {
 iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }

      const mapped_type&
      at(const key_type& __k) const
      {
 const_iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }
# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }
# 538 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_unique_(__position, __x); }
# 550 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_unique(__first, __last); }
# 565 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 595 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 610 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      void



      swap(map& __x)

      { _M_t.swap(__x._M_t); }







      void
      clear()
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 699 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 714 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }







      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }







      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 753 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 772 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator==(const map<_K1, _T1, _C1, _A1>&,
     const map<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator<(const map<_K1, _T1, _C1, _A1>&,
    const map<_K1, _T1, _C1, _A1>&);
    };
# 797 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 814 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
              const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
              const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
               const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
  map<_Key, _Tp, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 869 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_map.h" 3
}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
#define _STL_MULTIMAP_H 1




namespace std __attribute__ ((__visibility__ ("default"))) {
# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
  template <typename _Key, typename _Tp,
     typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class multimap
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class multimap<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename _Alloc::template rebind<value_type>::other
        _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;

      _Rep_type _M_t;

    public:


      typedef typename _Pair_alloc_type::pointer pointer;
      typedef typename _Pair_alloc_type::const_pointer const_pointer;
      typedef typename _Pair_alloc_type::reference reference;
      typedef typename _Pair_alloc_type::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;






      multimap()
      : _M_t() { }






      explicit
      multimap(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      multimap(const multimap& __x)
      : _M_t(__x._M_t) { }
# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_equal(__first, __last); }
# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
        : _M_t(__comp, __a)
        { _M_t._M_insert_equal(__first, __last); }
# 247 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 292 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }







      iterator
      begin()
      { return _M_t.begin(); }






      const_iterator
      begin() const
      { return _M_t.begin(); }






      iterator
      end()
      { return _M_t.end(); }






      const_iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin()
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend()
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const
      { return _M_t.rend(); }
# 409 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_equal_(__position, __x); }
# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_equal(__first, __last); }
# 501 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 546 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      void



      swap(multimap& __x)

      { _M_t.swap(__x._M_t); }







      void
      clear()
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 608 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }






      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }







      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }







      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator==(const multimap<_K1, _T1, _C1, _A1>&,
     const multimap<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
        friend bool
        operator<(const multimap<_K1, _T1, _C1, _A1>&,
    const multimap<_K1, _T1, _C1, _A1>&);
  };
# 726 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 743 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 798 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multimap.h" 3
}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/map" 2 3
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" 2



# 1 "/usr/include/boost-1_41/boost/serialization/map.hpp" 1

#define BOOST_SERIALIZATION_MAP_HPP 
# 24 "/usr/include/boost-1_41/boost/serialization/map.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/utility.hpp" 1

#define BOOST_SERIALIZATION_UTILITY_HPP 
# 25 "/usr/include/boost-1_41/boost/serialization/utility.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/is_bitwise_serializable.hpp" 1
# 17 "/usr/include/boost-1_41/boost/serialization/is_bitwise_serializable.hpp"
#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP 
# 27 "/usr/include/boost-1_41/boost/serialization/is_bitwise_serializable.hpp"
namespace boost {
namespace serialization {
    template<class T>
    struct is_bitwise_serializable
     : public is_arithmetic<T>
    {};
}
}



#define BOOST_IS_BITWISE_SERIALIZABLE(T) namespace boost { namespace serialization { template<> struct is_bitwise_serializable< T > : mpl::true_ {}; }}
# 26 "/usr/include/boost-1_41/boost/serialization/utility.hpp" 2


namespace boost {
namespace serialization {


template<class Archive, class F, class S>
inline void serialize(
    Archive & ar,
    std::pair<F, S> & p,
    const unsigned int
){



    typedef typename boost::remove_const<F>::type typef;
    ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
    ar & boost::serialization::make_nvp("second", p.second);
}


template <class T, class U>
struct is_bitwise_serializable<std::pair<T,U> >
 : public mpl::and_<is_bitwise_serializable<T>,is_bitwise_serializable<U> >
{
};

}
}
# 25 "/usr/include/boost-1_41/boost/serialization/map.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/collections_save_imp.hpp" 1

#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP 
# 23 "/usr/include/boost-1_41/boost/serialization/collections_save_imp.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/serialization.hpp" 1

#define BOOST_SERIALIZATION_SERIALIZATION_HPP 
# 16 "/usr/include/boost-1_41/boost/serialization/serialization.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/throw_exception.hpp" 1

#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/serialization/throw_exception.hpp"
namespace boost {
namespace serialization {
# 35 "/usr/include/boost-1_41/boost/serialization/throw_exception.hpp"
template<class E> inline void throw_exception(E const & e){
    throw e;
}



}
}
# 17 "/usr/include/boost-1_41/boost/serialization/serialization.hpp" 2



#define BOOST_SERIALIZATION_LIBRARY_VERSION 19
# 64 "/usr/include/boost-1_41/boost/serialization/serialization.hpp"
namespace boost {
namespace serialization {

struct version_type : boost::totally_ordered1< version_type , boost::totally_ordered2< version_type, unsigned int > > { unsigned int t; explicit version_type(const unsigned int t_) : t(t_) {}; version_type(){}; version_type(const version_type & t_) : t(t_.t){} version_type & operator=(const version_type & rhs) { t = rhs.t; return *this;} version_type & operator=(const unsigned int & rhs) { t = rhs; return *this;} operator const unsigned int & () const {return t; } operator unsigned int & () { return t; } bool operator==(const version_type & rhs) const { return t == rhs.t; } bool operator<(const version_type & rhs) const { return t < rhs.t; } };


template<class Archive, class T>
inline void serialize(
    Archive & ar, T & t, const unsigned int file_version
){
    access::serialize(ar, t, static_cast<unsigned int>(file_version));
}


template<class Archive, class T>
inline void save_construct_data(
    Archive & ,
    const T * ,
    const unsigned int
){


}


template<class Archive, class T>
inline void load_construct_data(
    Archive & ,
    T * t,
    const unsigned int
){



    access::construct(t);
}
# 117 "/usr/include/boost-1_41/boost/serialization/serialization.hpp"
template<class Archive, class T>
inline void serialize_adl(
    Archive & ar,
    T & t,
    const unsigned int file_version
){
# 132 "/usr/include/boost-1_41/boost/serialization/serialization.hpp"
        const version_type v(file_version);
        serialize(ar, t, v);



}

template<class Archive, class T>
inline void save_construct_data_adl(
    Archive & ar,
    const T * t,
    const unsigned int file_version
){


        const version_type v(file_version);
        save_construct_data(ar, t, v);



}

template<class Archive, class T>
inline void load_construct_data_adl(
    Archive & ar,
    T * t,
    const unsigned int file_version
){


        const version_type v(file_version);
        load_construct_data(ar, t, v);



}

}
}
# 24 "/usr/include/boost-1_41/boost/serialization/collections_save_imp.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/version.hpp" 1

#define BOOST_SERIALIZATION_VERSION_HPP 
# 28 "/usr/include/boost-1_41/boost/serialization/version.hpp"
namespace boost {
namespace serialization {

struct basic_traits;



template<class T>
struct version
{
    template<class U>
    struct traits_class_version {
        typedef typename U::version type;
    };

    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits,T>,
            traits_class_version<T>,
            mpl::int_<0>
        >::type type;
    static const int value = version::type::value;
};

}
}
# 71 "/usr/include/boost-1_41/boost/serialization/version.hpp"
#define BOOST_CLASS_VERSION(T,N) namespace boost { namespace serialization { template<> struct version<T > { typedef mpl::int_<N> type; typedef mpl::integral_c_tag tag; BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value); }; } }
# 25 "/usr/include/boost-1_41/boost/serialization/collections_save_imp.hpp" 2


namespace boost{
namespace serialization {
namespace stl {





template<class Archive, class Container>
inline void save_collection(Archive & ar, const Container &s)
{

    collection_size_type const count(s.size());
    ar << boost::serialization::make_nvp("count", count);


    if(3 < ar.get_library_version()){
        const unsigned int item_version = version<
            typename Container::value_type
        >::value;
        ar << boost::serialization::make_nvp("item_version", item_version);
    }
    typename Container::const_iterator it = s.begin();
    std::size_t c=count;
    while(c-- > 0){

            boost::serialization::save_construct_data_adl(
                ar,
                &(*it),
                boost::serialization::version<
                    typename Container::value_type
                >::value
            );
        ar << boost::serialization::make_nvp("item", *it++);
    }
}

}
}
}
# 26 "/usr/include/boost-1_41/boost/serialization/map.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp" 1

#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP 
# 25 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 1 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3
       
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 2 3
# 26 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 27 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp" 2
# 37 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp"
# 1 "/usr/include/boost-1_41/boost/serialization/detail/stack_constructor.hpp" 1

#define BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP 
# 25 "/usr/include/boost-1_41/boost/serialization/detail/stack_constructor.hpp"
namespace boost{
namespace serialization {
namespace detail {



template<typename T >
struct stack_allocate
{
    T * address() {
        return static_cast<T*>(storage_.address());
    }
    T & reference() {
        return * address();
    }
private:
    typedef typename boost::aligned_storage<
        sizeof(T),



            boost::alignment_of<T>::value

    > type;
    type storage_;
};


template<class Archive, class T>
struct stack_construct : public stack_allocate<T>
{
    stack_construct(Archive & ar, const unsigned int version){

        boost::serialization::load_construct_data_adl(
            ar,
            this->address(),
            version
        );
    }
    ~stack_construct(){
        this->address()->~T();
    }
};

}
}
}
# 38 "/usr/include/boost-1_41/boost/serialization/collections_load_imp.hpp" 2



namespace boost{
namespace serialization {
namespace stl {






template<class Archive, class Container>
struct archive_input_seq
{
    inline void operator()(
        Archive &ar,
        Container &s,
        const unsigned int v
    ){
        typedef typename Container::value_type type;
        detail::stack_construct<Archive, type> t(ar, v);

        ar >> boost::serialization::make_nvp("item", t.reference());
        s.push_back(t.reference());
        ar.reset_object_address(& s.back() , & t.reference());
    }
};


template<class Archive, class Container>
struct archive_input_map
{
    inline void operator()(
        Archive &ar,
        Container &s,
        const unsigned int v
    ){
        typedef typename Container::value_type type;
        detail::stack_construct<Archive, type> t(ar, v);

        ar >> boost::serialization::make_nvp("item", t.reference());
        std::pair<typename Container::const_iterator, bool> result =
            s.insert(t.reference());



        if(result.second){
            ar.reset_object_address(
                & (result.first->second),
                & t.reference().second
            );
        }
    }
};


template<class Archive, class Container>
struct archive_input_multimap
{
    inline void operator()(
        Archive &ar,
        Container &s,
        const unsigned int v
    ){
        typedef typename Container::value_type type;
        detail::stack_construct<Archive, type> t(ar, v);

        ar >> boost::serialization::make_nvp("item", t.reference());
        typename Container::const_iterator result
            = s.insert(t.reference());



        ar.reset_object_address(
            & result->second,
            & t.reference()
        );
    }
};


template<class Archive, class Container>
struct archive_input_set
{
    inline void operator()(
        Archive &ar,
        Container &s,
        const unsigned int v
    ){
        typedef typename Container::value_type type;
        detail::stack_construct<Archive, type> t(ar, v);

        ar >> boost::serialization::make_nvp("item", t.reference());
        std::pair<typename Container::const_iterator, bool> result =
            s.insert(t.reference());
        if(result.second)
            ar.reset_object_address(& (* result.first), & t.reference());
    }
};


template<class Archive, class Container>
struct archive_input_multiset
{
    inline void operator()(
        Archive &ar,
        Container &s,
        const unsigned int v
    ){
        typedef typename Container::value_type type;
        detail::stack_construct<Archive, type> t(ar, v);

        ar >> boost::serialization::make_nvp("item", t.reference());
        typename Container::const_iterator result
            = s.insert(t.reference());
        ar.reset_object_address(& (* result), & t.reference());
    }
};

template<class Container>
class reserve_imp
{
public:
    void operator()(Container &s, std::size_t count) const {
        s.reserve(count);
    }
};

template<class Container>
class no_reserve_imp
{
public:
    void operator()(Container & , std::size_t ) const{}
};

template<class Archive, class Container, class InputFunction, class R>
inline void load_collection(Archive & ar, Container &s)
{
    s.clear();

    collection_size_type count;
    unsigned int item_version;
    ar >> boost::serialization::make_nvp("count", count);
    if(3 < ar.get_library_version())
        ar >> boost::serialization::make_nvp("item_version", item_version);
    else
        item_version = 0;
    R rx;
    rx(s, count);
    std::size_t c = count;
    InputFunction ifunc;
    while(c-- > 0){
        ifunc(ar, s, item_version);
    }
}

}
}
}
# 27 "/usr/include/boost-1_41/boost/serialization/map.hpp" 2
# 1 "/usr/include/boost-1_41/boost/serialization/split_free.hpp" 1

#define BOOST_SERIALIZATION_SPLIT_FREE_HPP 
# 24 "/usr/include/boost-1_41/boost/serialization/split_free.hpp"
namespace boost {
namespace archive {
    namespace detail {
        template<class Archive> class interface_oarchive;
        template<class Archive> class interface_iarchive;
    }
}

namespace serialization {


template<class Archive, class T>
struct free_saver {
    static void invoke(
        Archive & ar,
        const T & t,
        const unsigned int file_version
    ){


        const version_type v(file_version);
        save(ar, t, v);
    }
};
template<class Archive, class T>
struct free_loader {
    static void invoke(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){


        const version_type v(file_version);
        load(ar, t, v);
    }
};


template<class Archive, class T>
inline void split_free(
    Archive & ar,
    T & t,
    const unsigned int file_version
){
    typedef typename mpl::eval_if<
        typename Archive::is_saving,
        mpl::identity< free_saver<Archive, T> >,
        mpl::identity< free_loader<Archive, T> >
    >::type typex;
    typex::invoke(ar, t, file_version);
}

}
}

#define BOOST_SERIALIZATION_SPLIT_FREE(T) namespace boost { namespace serialization { template<class Archive> inline void serialize( Archive & ar, T & t, const unsigned int file_version ){ split_free(ar, t, file_version); } }}
# 28 "/usr/include/boost-1_41/boost/serialization/map.hpp" 2

namespace boost {
namespace serialization {

template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void save(
    Archive & ar,
    const std::map<Key, Type, Compare, Allocator> &t,
    const unsigned int
){
    boost::serialization::stl::save_collection<
        Archive,
        std::map<Key, Type, Compare, Allocator>
    >(ar, t);
}

template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void load(
    Archive & ar,
    std::map<Key, Type, Compare, Allocator> &t,
    const unsigned int
){
    boost::serialization::stl::load_collection<
        Archive,
        std::map<Key, Type, Compare, Allocator>,
        boost::serialization::stl::archive_input_map<
            Archive, std::map<Key, Type, Compare, Allocator> >,
            boost::serialization::stl::no_reserve_imp<std::map<
                Key, Type, Compare, Allocator
            >
        >
    >(ar, t);
}



template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void serialize(
    Archive & ar,
    std::map<Key, Type, Compare, Allocator> &t,
    const unsigned int file_version
){
    boost::serialization::split_free(ar, t, file_version);
}


template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void save(
    Archive & ar,
    const std::multimap<Key, Type, Compare, Allocator> &t,
    const unsigned int
){
    boost::serialization::stl::save_collection<
        Archive,
        std::multimap<Key, Type, Compare, Allocator>
    >(ar, t);
}

template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void load(
    Archive & ar,
    std::multimap<Key, Type, Compare, Allocator> &t,
    const unsigned int
){
    boost::serialization::stl::load_collection<
        Archive,
        std::multimap<Key, Type, Compare, Allocator>,
        boost::serialization::stl::archive_input_multimap<
            Archive, std::multimap<Key, Type, Compare, Allocator>
        >,
        boost::serialization::stl::no_reserve_imp<
            std::multimap<Key, Type, Compare, Allocator>
        >
    >(ar, t);
}



template<class Archive, class Type, class Key, class Compare, class Allocator >
inline void serialize(
    Archive & ar,
    std::multimap<Key, Type, Compare, Allocator> &t,
    const unsigned int file_version
){
    boost::serialization::split_free(ar, t, file_version);
}

}
}
# 21 "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" 2





namespace boost { namespace numeric { namespace ublas {

    namespace detail {

        template<class I, class T, class C>
       
        I lower_bound (const I &begin, const I &end, const T &t, C compare) {

            if (begin == end || ! compare (*begin, t))
                return begin;
            if (compare (*(end - 1), t))
                return end;
            return std::lower_bound (begin, end, t, compare);
        }
        template<class I, class T, class C>
       
        I upper_bound (const I &begin, const I &end, const T &t, C compare) {
            if (begin == end || compare (t, *begin))
                return begin;

            if (! compare (t, *(end - 1)))
                return end;
            return std::upper_bound (begin, end, t, compare);
        }

        template<class P>
        struct less_pair {
           
            bool operator () (const P &p1, const P &p2) {
                return p1.first < p2.first;
            }
        };
        template<class T>
        struct less_triple {
           
            bool operator () (const T &t1, const T &t2) {
                return t1.first.first < t2.first.first ||
                       (t1.first.first == t2.first.first && t1.first.second < t2.first.second);
            }
        };

    }
# 199 "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp"
    template<class I, class T, class ALLOC>
    class map_std : public std::map<I, T > {
    public:

        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            ar & serialization::make_nvp("base", boost::serialization::base_object< std::map<I, T > >(*this));
        }
    };






    template<class I, class T, class ALLOC>
    class map_array {
    public:
        typedef ALLOC allocator_type;
        typedef typename ALLOC::size_type size_type;
        typedef typename ALLOC::difference_type difference_type;
        typedef std::pair<I,T> value_type;
        typedef I key_type;
        typedef T mapped_type;
        typedef const value_type &const_reference;
        typedef value_type &reference;
        typedef const value_type *const_pointer;
        typedef value_type *pointer;

        typedef const_pointer const_iterator;
        typedef pointer iterator;

        typedef const T &data_const_reference;

        typedef T &data_reference;





       
        map_array (const ALLOC &a = ALLOC()):
            alloc_(a), capacity_ (0), size_ (0) {
                data_ = 0;
        }
       
        map_array (const map_array &c):
            alloc_ (c.alloc_), capacity_ (c.size_), size_ (c.size_) {
            if (capacity_) {
                data_ = alloc_.allocate (capacity_);
                std::uninitialized_copy (data_, data_ + capacity_, c.data_);

            }
            else
                data_ = 0;
        }
       
        ~map_array () {
            if (capacity_) {
                std::for_each (data_, data_ + capacity_, static_destroy);
                alloc_.deallocate (data_, capacity_);
            }
        }

    private:

       
        void resize (size_type size) {
            if (! (size_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 267 << ":" << std::endl; std::cerr << "size_ <= capacity_" << std::endl; internal_logic ().raise (); };
            if (size > capacity_) {
                const size_type capacity = size << 1;
                if (! (capacity)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 270 << ":" << std::endl; std::cerr << "capacity" << std::endl; internal_logic ().raise (); };
                pointer data = alloc_.allocate (capacity);
                std::uninitialized_copy (data_, data_ + (std::min) (size, size_), data);
                std::uninitialized_fill (data + (std::min) (size, size_), data + capacity, value_type ());

                if (capacity_) {
                    std::for_each (data_, data_ + capacity_, static_destroy);
                    alloc_.deallocate (data_, capacity_);
                }
                capacity_ = capacity;
                data_ = data;
            }
            size_ = size;
            if (! (size_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 283 << ":" << std::endl; std::cerr << "size_ <= capacity_" << std::endl; internal_logic ().raise (); };
        }
    public:


       
        void reserve (size_type capacity) {
            if (! (size_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 290 << ":" << std::endl; std::cerr << "size_ <= capacity_" << std::endl; internal_logic ().raise (); };

            if (! (capacity >= size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 292 << ":" << std::endl; std::cerr << "capacity >= size_" << std::endl; bad_size ().raise (); };
            pointer data;
            if (capacity) {
                data = alloc_.allocate (capacity);
                std::uninitialized_copy (data_, data_ + size_, data);
                std::uninitialized_fill (data + size_, data + capacity, value_type ());
            }
            else
                data = 0;

            if (capacity_) {
                std::for_each (data_, data_ + capacity_, static_destroy);
                alloc_.deallocate (data_, capacity_);
            }
            capacity_ = capacity;
            data_ = data;
            if (! (size_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 308 << ":" << std::endl; std::cerr << "size_ <= capacity_" << std::endl; internal_logic ().raise (); };
        }


       
        size_type size () const {
            return size_;
        }
       
        size_type capacity () const {
            return capacity_;
        }
       
        size_type max_size () const {
            return 0;
        }

       
        bool empty () const {
            return size_ == 0;
        }


       
        data_reference operator [] (key_type i) {

            pointer it = find (i);
            if (it == end ())
                it = insert (end (), value_type (i, mapped_type (0)));
            if (! (it != end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 337 << ":" << std::endl; std::cerr << "it != end ()" << std::endl; internal_logic ().raise (); };
            return it->second;



        }


       
        map_array &operator = (const map_array &a) {
            if (this != &a) {
                resize (a.size_);
                std::copy (a.data_, a.data_ + a.size_, data_);
            }
            return *this;
        }
       
        map_array &assign_temporary (map_array &a) {
            swap (a);
            return *this;
        }


       
        void swap (map_array &a) {
            if (this != &a) {
                std::swap (capacity_, a.capacity_);
                std::swap (data_, a.data_);
                std::swap (size_, a.size_);
            }
        }
       
        friend void swap (map_array &a1, map_array &a2) {
            a1.swap (a2);
        }





        iterator push_back (iterator it, const value_type &p) {
            if (size () == 0 || (it = end () - 1)->first < p.first) {
                resize (size () + 1);
                *(it = end () - 1) = p;
                return it;
            }
            external_logic ().raise ();
            return it;
        }


        std::pair<iterator,bool> insert (const value_type &p) {
            iterator it = detail::lower_bound (begin (), end (), p, detail::less_pair<value_type> ());
            if (it != end () && it->first == p.first)
                return std::make_pair (it, false);
            difference_type n = it - begin ();
            resize (size () + 1);
            it = begin () + n;
            std::copy_backward (it, end () - 1, end ());
            *it = p;
            return std::make_pair (it, true);
        }


        iterator insert (iterator hint, const value_type &p) {
            return insert (p).first;
        }

        void erase (iterator it) {
            if (! (begin () <= it && it < end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 406 << ":" << std::endl; std::cerr << "begin () <= it && it < end ()" << std::endl; bad_index ().raise (); };
            std::copy (it + 1, end (), it);
            resize (size () - 1);
        }

        void erase (iterator it1, iterator it2) {
            if (it1 == it2) return ;
            if (! (begin () <= it1 && it1 < it2 && it2 <= end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/storage_sparse.hpp" << " at line " << 413 << ":" << std::endl; std::cerr << "begin () <= it1 && it1 < it2 && it2 <= end ()" << std::endl; bad_index ().raise (); };
            std::copy (it2, end (), it1);
            resize (size () - (it2 - it1));
        }

        void clear () {
            resize (0);
        }



        const_iterator find (key_type i) const {
            const_iterator it (detail::lower_bound (begin (), end (), value_type (i, mapped_type (0)), detail::less_pair<value_type> ()));
            if (it == end () || it->first != i)
                it = end ();
            return it;
        }

        iterator find (key_type i) {
            iterator it (detail::lower_bound (begin (), end (), value_type (i, mapped_type (0)), detail::less_pair<value_type> ()));
            if (it == end () || it->first != i)
                it = end ();
            return it;
        }

        const_iterator lower_bound (key_type i) const {
            return detail::lower_bound (begin (), end (), value_type (i, mapped_type (0)), detail::less_pair<value_type> ());
        }

        iterator lower_bound (key_type i) {
            return detail::lower_bound (begin (), end (), value_type (i, mapped_type (0)), detail::less_pair<value_type> ());
        }

       
        const_iterator begin () const {
            return data_;
        }
       
        const_iterator end () const {
            return data_ + size_;
        }

       
        iterator begin () {
            return data_;
        }
       
        iterator end () {
            return data_ + size_;
        }


        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
        typedef std::reverse_iterator<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        allocator_type get_allocator () {
            return alloc_;
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                resize(s);
            }
            ar & serialization::make_array(data_, s);
        }

    private:

       
        static void static_destroy (reference p) {
            (&p) -> ~value_type ();
        }
        ALLOC alloc_;
        size_type capacity_;
        pointer data_;
        size_type size_;
    };


    namespace detail {
        template<class A, class T>
        struct map_traits {
            typedef typename A::mapped_type &reference;
        };
        template<class I, class T, class ALLOC>
        struct map_traits<map_array<I, T, ALLOC>, T > {
            typedef typename map_array<I, T, ALLOC>::data_reference reference;
        };




        template<class M>
       
        void map_reserve (M & , typename M::size_type ) {
        }
        template<class I, class T, class ALLOC>
       
        void map_reserve (map_array<I, T, ALLOC> &m, typename map_array<I, T, ALLOC>::size_type capacity) {
            m.reserve (capacity);
        }

        template<class M>
        struct map_capacity_traits {
            typedef typename M::size_type type ;
            type operator() ( M const& m ) const {
               return m.size ();
            }
        } ;

        template<class I, class T, class ALLOC>
        struct map_capacity_traits< map_array<I, T, ALLOC> > {
            typedef typename map_array<I, T, ALLOC>::size_type type ;
            type operator() ( map_array<I, T, ALLOC> const& m ) const {
               return m.capacity ();
            }
        } ;

        template<class M>
       
        typename map_capacity_traits<M>::type map_capacity (M const& m) {
            return map_capacity_traits<M>() ( m );
        }
    }

}}}
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" 2
# 25 "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp"
namespace boost { namespace numeric { namespace ublas {



    template<class V>
    class sparse_vector_element:
       public container_reference<V> {
    public:
        typedef V vector_type;
        typedef typename V::size_type size_type;
        typedef typename V::value_type value_type;
        typedef const value_type &const_reference;
        typedef value_type *pointer;

    private:

        void get_d () const {
            pointer p = (*this) ().find_element (i_);
            if (p)
                d_ = *p;
            else
                d_ = value_type ();
        }

        void set (const value_type &s) const {
            pointer p = (*this) ().find_element (i_);
            if (!p)
                (*this) ().insert_element (i_, s);
            else
                *p = s;
        }

    public:

        sparse_vector_element (vector_type &v, size_type i):
            container_reference<vector_type> (v), i_ (i) {
        }
       
        sparse_vector_element (const sparse_vector_element &p):
            container_reference<vector_type> (p), i_ (p.i_) {}
       
        ~sparse_vector_element () {
        }


       
        sparse_vector_element &operator = (const sparse_vector_element &p) {

            p.get_d ();
            set (p.d_);
            return *this;
        }
        template<class D>
       
        sparse_vector_element &operator = (const D &d) {
            set (d);
            return *this;
        }
        template<class D>
       
        sparse_vector_element &operator += (const D &d) {
            get_d ();
            d_ += d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_vector_element &operator -= (const D &d) {
            get_d ();
            d_ -= d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_vector_element &operator *= (const D &d) {
            get_d ();
            d_ *= d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_vector_element &operator /= (const D &d) {
            get_d ();
            d_ /= d;
            set (d_);
            return *this;
        }


        template<class D>
       
        bool operator == (const D &d) const {
            get_d ();
            return d_ == d;
        }
        template<class D>
       
        bool operator != (const D &d) const {
            get_d ();
            return d_ != d;
        }


       
        operator const_reference () const {
            get_d ();
            return d_;
        }


       
        value_type& ref () const {
            const pointer p = (*this) ().find_element (i_);
            if (!p)
                return (*this) ().insert_element (i_, value_type ());
            else
                return *p;
        }

    private:
        size_type i_;
        mutable value_type d_;
    };




    namespace detail {
        template <class R>
        struct element_reference {
            typedef R& reference;
            static reference get_reference (reference r)
            {
                return r;
            }
        };
        template <class V>
        struct element_reference<sparse_vector_element<V> > {
            typedef typename V::value_type& reference;
            static reference get_reference (const sparse_vector_element<V>& sve)
            {
                return sve.ref ();
            }
        };
    }
    template <class VER>
    typename detail::element_reference<VER>::reference ref (VER& ver) {
        return detail::element_reference<VER>::get_reference (ver);
    }
    template <class VER>
    typename detail::element_reference<VER>::reference ref (const VER& ver) {
        return detail::element_reference<VER>::get_reference (ver);
    }


    template<class V>
    struct type_traits<sparse_vector_element<V> > {
        typedef typename V::value_type element_type;
        typedef type_traits<sparse_vector_element<V> > self_type;
        typedef typename type_traits<element_type>::value_type value_type;
        typedef typename type_traits<element_type>::const_reference const_reference;
        typedef sparse_vector_element<V> reference;
        typedef typename type_traits<element_type>::real_type real_type;
        typedef typename type_traits<element_type>::precision_type precision_type;

        static const unsigned plus_complexity = type_traits<element_type>::plus_complexity;
        static const unsigned multiplies_complexity = type_traits<element_type>::multiplies_complexity;

        static
       
        real_type real (const_reference t) {
            return type_traits<element_type>::real (t);
        }
        static
       
        real_type imag (const_reference t) {
            return type_traits<element_type>::imag (t);
        }
        static
       
        value_type conj (const_reference t) {
            return type_traits<element_type>::conj (t);
        }

        static
       
        real_type type_abs (const_reference t) {
            return type_traits<element_type>::type_abs (t);
        }
        static
       
        value_type type_sqrt (const_reference t) {
            return type_traits<element_type>::type_sqrt (t);
        }

        static
       
        real_type norm_1 (const_reference t) {
            return type_traits<element_type>::norm_1 (t);
        }
        static
       
        real_type norm_2 (const_reference t) {
            return type_traits<element_type>::norm_2 (t);
        }
        static
       
        real_type norm_inf (const_reference t) {
            return type_traits<element_type>::norm_inf (t);
        }

        static
       
        bool equals (const_reference t1, const_reference t2) {
            return type_traits<element_type>::equals (t1, t2);
        }
    };

    template<class V1, class T2>
    struct promote_traits<sparse_vector_element<V1>, T2> {
        typedef typename promote_traits<typename sparse_vector_element<V1>::value_type, T2>::promote_type promote_type;
    };
    template<class T1, class V2>
    struct promote_traits<T1, sparse_vector_element<V2> > {
        typedef typename promote_traits<T1, typename sparse_vector_element<V2>::value_type>::promote_type promote_type;
    };
    template<class V1, class V2>
    struct promote_traits<sparse_vector_element<V1>, sparse_vector_element<V2> > {
        typedef typename promote_traits<typename sparse_vector_element<V1>::value_type,
                                        typename sparse_vector_element<V2>::value_type>::promote_type promote_type;
    };





    template<class T, class A>
    class mapped_vector:
        public vector_container<mapped_vector<T, A> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef mapped_vector<T, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef A array_type;
        typedef const value_type &const_reference;



        typedef sparse_vector_element<self_type> reference;

        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef self_type vector_temporary_type;
        typedef sparse_tag storage_category;


       
        mapped_vector ():
            vector_container<self_type> (),
            size_ (0), data_ () {}
       
        mapped_vector (size_type size, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (size), data_ () {
            detail::map_reserve (data(), restrict_capacity (non_zeros));
        }
       
        mapped_vector (const mapped_vector &v):
            vector_container<self_type> (),
            size_ (v.size_), data_ (v.data_) {}
        template<class AE>
       
        mapped_vector (const vector_expression<AE> &ae, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (ae ().size ()), data_ () {
            detail::map_reserve (data(), restrict_capacity (non_zeros));
            vector_assign<scalar_assign> (*this, ae);
        }


       
        size_type size () const {
            return size_;
        }
       
        size_type nnz_capacity () const {
            return detail::map_capacity (data ());
        }
       
        size_type nnz () const {
            return data (). size ();
        }


       
        const array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


    private:
       
        size_type restrict_capacity (size_type non_zeros) const {
            non_zeros = (std::min) (non_zeros, size_);
            return non_zeros;
        }
    public:
       
        void resize (size_type size, bool preserve = true) {
            size_ = size;
            if (preserve) {
                data ().erase (data ().lower_bound(size_), data ().end());
            }
            else {
                data ().clear ();
            }
        }


       
        void reserve (size_type non_zeros = 0, bool preserve = true) {
            detail::map_reserve (data (), restrict_capacity (non_zeros));
        }


       
        pointer find_element (size_type i) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
        }
       
        const_pointer find_element (size_type i) const {
            const_subiterator_type it (data ().find (i));
            if (it == data ().end ())
                return 0;
            if (! ((*it).first == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 374 << ":" << std::endl; std::cerr << "(*it).first == i" << std::endl; internal_logic ().raise (); };
            return &(*it).second;
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 381 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            const_subiterator_type it (data ().find (i));
            if (it == data ().end ())
                return zero_;
            if (! ((*it).first == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 385 << ":" << std::endl; std::cerr << "(*it).first == i" << std::endl; internal_logic ().raise (); };
            return (*it).second;
        }
       
        true_reference ref (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 390 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            std::pair<subiterator_type, bool> ii (data ().insert (typename array_type::value_type (i, value_type ())));
            if (! ((ii.first)->first == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 392 << ":" << std::endl; std::cerr << "(ii.first)->first == i" << std::endl; internal_logic ().raise (); };
            return (ii.first)->second;
        }
       
        reference operator () (size_type i) {



            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 400 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return reference (*this, i);

        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        true_reference insert_element (size_type i, const_reference t) {
            std::pair<subiterator_type, bool> ii = data ().insert (typename array_type::value_type (i, t));
            if (! (ii.second)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 418 << ":" << std::endl; std::cerr << "ii.second" << std::endl; bad_index ().raise (); };
            if (! ((ii.first)->first == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 419 << ":" << std::endl; std::cerr << "(ii.first)->first == i" << std::endl; internal_logic ().raise (); };
            if (!ii.second)
                (ii.first)->second = t;
            return (ii.first)->second;
        }
       
        void erase_element (size_type i) {
            subiterator_type it = data ().find (i);
            if (it == data ().end ())
                return;
            data ().erase (it);
        }


       
        void clear () {
            data ().clear ();
        }


       
        mapped_vector &operator = (const mapped_vector &v) {
            if (this != &v) {
                size_ = v.size_;
                data () = v.data ();
            }
            return *this;
        }
        template<class C>
       
        mapped_vector &operator = (const vector_container<C> &v) {
            resize (v ().size (), false);
            assign (v);
            return *this;
        }
       
        mapped_vector &assign_temporary (mapped_vector &v) {
            swap (v);
            return *this;
        }
        template<class AE>
       
        mapped_vector &operator = (const vector_expression<AE> &ae) {
            self_type temporary (ae, detail::map_capacity (data()));
            return assign_temporary (temporary);
        }
        template<class AE>
       
        mapped_vector &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }


        template<class AE>
       
        mapped_vector &operator += (const vector_expression<AE> &ae) {
            self_type temporary (*this + ae, detail::map_capacity (data()));
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_vector &operator += (const vector_container<C> &v) {
            plus_assign (v);
            return *this;
        }
        template<class AE>
       
        mapped_vector &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        mapped_vector &operator -= (const vector_expression<AE> &ae) {
            self_type temporary (*this - ae, detail::map_capacity (data()));
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_vector &operator -= (const vector_container<C> &v) {
            minus_assign (v);
            return *this;
        }
        template<class AE>
       
        mapped_vector &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        mapped_vector &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        mapped_vector &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (mapped_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
                data ().swap (v.data ());
            }
        }
       
        friend void swap (mapped_vector &v1, mapped_vector &v2) {
            v1.swap (v2);
        }


    private:

        typedef typename A::const_iterator const_subiterator_type;
        typedef typename A::iterator subiterator_type;

       
        true_reference at_element (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 543 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            subiterator_type it (data ().find (i));
            if (! (it != data ().end())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 545 << ":" << std::endl; std::cerr << "it != data ().end()" << std::endl; bad_index ().raise (); };
            if (! ((*it).first == i)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 546 << ":" << std::endl; std::cerr << "(*it).first == i" << std::endl; internal_logic ().raise (); };
            return it->second;
        }

    public:
        class const_iterator;
        class iterator;



        const_iterator find (size_type i) const {
            return const_iterator (*this, data ().lower_bound (i));
        }

        iterator find (size_type i) {
            return iterator (*this, data ().lower_bound (i));
        }


        class const_iterator:
            public container_const_reference<mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename mapped_vector::value_type value_type;
            typedef typename mapped_vector::difference_type difference_type;
            typedef typename mapped_vector::const_reference reference;
            typedef const typename mapped_vector::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &v, const const_subiterator_type &it):
                container_const_reference<self_type> (v), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 601 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*it_).second;
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 608 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*it_).first < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 609 << ":" << std::endl; std::cerr << "(*it_).first < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*it_).first;
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 624 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

       
        const_iterator begin () const {
            return const_iterator (*this, data ().begin ());
        }
       
        const_iterator end () const {
            return const_iterator (*this, data ().end ());
        }

        class iterator:
            public container_reference<mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator, value_type> {
        public:
            typedef typename mapped_vector::value_type value_type;
            typedef typename mapped_vector::difference_type difference_type;
            typedef typename mapped_vector::true_reference reference;
            typedef typename mapped_vector::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &v, const subiterator_type &it):
                container_reference<self_type> (v), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 674 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*it_).second;
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 681 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*it_).first < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 682 << ":" << std::endl; std::cerr << "(*it_).first < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*it_).first;
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 697 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return iterator (*this, data ().begin ());
        }
       
        iterator end () {
            return iterator (*this, data ().end ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }
            ar & serialization::make_nvp("data", data_);
        }

    private:
        size_type size_;
        array_type data_;
        static const value_type zero_;
    };

    template<class T, class A>
    const typename mapped_vector<T, A>::value_type mapped_vector<T, A>::zero_ = value_type ();




    template<class T, std::size_t IB, class IA, class TA>
    class compressed_vector:
        public vector_container<compressed_vector<T, IB, IA, TA> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef compressed_vector<T, IB, IA, TA> self_type;
    public:





        typedef typename IA::value_type size_type;
        typedef typename IA::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;



        typedef sparse_vector_element<self_type> reference;

        typedef IA index_array_type;
        typedef TA value_array_type;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef self_type vector_temporary_type;
        typedef sparse_tag storage_category;


       
        compressed_vector ():
            vector_container<self_type> (),
            size_ (0), capacity_ (restrict_capacity (0)), filled_ (0),
            index_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
        }
        explicit
        compressed_vector (size_type size, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (size), capacity_ (restrict_capacity (non_zeros)), filled_ (0),
            index_data_ (capacity_), value_data_ (capacity_) {
        storage_invariants ();
        }
       
        compressed_vector (const compressed_vector &v):
            vector_container<self_type> (),
            size_ (v.size_), capacity_ (v.capacity_), filled_ (v.filled_),
            index_data_ (v.index_data_), value_data_ (v.value_data_) {
            storage_invariants ();
        }
        template<class AE>
       
        compressed_vector (const vector_expression<AE> &ae, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (ae ().size ()), capacity_ (restrict_capacity (non_zeros)), filled_ (0),
            index_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
            vector_assign<scalar_assign> (*this, ae);
        }


       
        size_type size () const {
            return size_;
        }
       
        size_type nnz_capacity () const {
            return capacity_;
        }
       
        size_type nnz () const {
            return filled_;
        }


       
        static size_type index_base () {
            return IB;
        }
       
        typename index_array_type::size_type filled () const {
            return filled_;
        }
       
        const index_array_type &index_data () const {
            return index_data_;
        }
       
        const value_array_type &value_data () const {
            return value_data_;
        }
       
        void set_filled (const typename index_array_type::size_type & filled) {
            filled_ = filled;
            storage_invariants ();
        }
       
        index_array_type &index_data () {
            return index_data_;
        }
       
        value_array_type &value_data () {
            return value_data_;
        }


    private:
       
        size_type restrict_capacity (size_type non_zeros) const {
            non_zeros = (std::max) (non_zeros, size_type (1));
            non_zeros = (std::min) (non_zeros, size_);
            return non_zeros;
        }
    public:
       
        void resize (size_type size, bool preserve = true) {
            size_ = size;
            capacity_ = restrict_capacity (capacity_);
            if (preserve) {
                index_data_. resize (capacity_, size_type ());
                value_data_. resize (capacity_, value_type ());
                filled_ = (std::min) (capacity_, filled_);
                while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) {
                    --filled_;
                }
            }
            else {
                index_data_. resize (capacity_);
                value_data_. resize (capacity_);
                filled_ = 0;
            }
            storage_invariants ();
        }


       
        void reserve (size_type non_zeros, bool preserve = true) {
            capacity_ = restrict_capacity (non_zeros);
            if (preserve) {
                index_data_. resize (capacity_, size_type ());
                value_data_. resize (capacity_, value_type ());
                filled_ = (std::min) (capacity_, filled_);
            }
            else {
                index_data_. resize (capacity_);
                value_data_. resize (capacity_);
                filled_ = 0;
            }
            storage_invariants ();
        }


       
        pointer find_element (size_type i) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
        }
       
        const_pointer find_element (size_type i) const {
            const_subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return 0;
            return &value_data_ [it - index_data_.begin ()];
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 929 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            const_subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return zero_;
            return value_data_ [it - index_data_.begin ()];
        }
       
        true_reference ref (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 937 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return insert_element (i, value_type ());
            else
                return value_data_ [it - index_data_.begin ()];
        }
       
        reference operator () (size_type i) {



            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 949 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return reference (*this, i);

        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        true_reference insert_element (size_type i, const_reference t) {
            if (! (!find_element (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 966 << ":" << std::endl; std::cerr << "!find_element (i)" << std::endl; bad_index ().raise (); };
            if (filled_ >= capacity_)
                reserve (2 * capacity_, true);
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));

            typename std::iterator_traits<subiterator_type>::difference_type n = it - index_data_.begin ();
            if (! (filled_ == 0 || filled_ == typename index_array_type::size_type (n) || *it != k_based (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 972 << ":" << std::endl; std::cerr << "filled_ == 0 || filled_ == typename index_array_type::size_type (n) || *it != k_based (i)" << std::endl; internal_logic ().raise (); };
            ++ filled_;
            it = index_data_.begin () + n;
            std::copy_backward (it, index_data_.begin () + filled_ - 1, index_data_.begin () + filled_);
            *it = k_based (i);
            typename value_array_type::iterator itt (value_data_.begin () + n);
            std::copy_backward (itt, value_data_.begin () + filled_ - 1, value_data_.begin () + filled_);
            *itt = t;
            storage_invariants ();
            return *itt;
        }
       
        void erase_element (size_type i) {
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            typename std::iterator_traits<subiterator_type>::difference_type n = it - index_data_.begin ();
            if (filled_ > typename index_array_type::size_type (n) && *it == k_based (i)) {
                std::copy (it + 1, index_data_.begin () + filled_, it);
                typename value_array_type::iterator itt (value_data_.begin () + n);
                std::copy (itt + 1, value_data_.begin () + filled_, itt);
                -- filled_;
            }
            storage_invariants ();
        }


       
        void clear () {
            filled_ = 0;
            storage_invariants ();
        }


       
        compressed_vector &operator = (const compressed_vector &v) {
            if (this != &v) {
                size_ = v.size_;
                capacity_ = v.capacity_;
                filled_ = v.filled_;
                index_data_ = v.index_data_;
                value_data_ = v.value_data_;
            }
            storage_invariants ();
            return *this;
        }
        template<class C>
       
        compressed_vector &operator = (const vector_container<C> &v) {
            resize (v ().size (), false);
            assign (v);
            return *this;
        }
       
        compressed_vector &assign_temporary (compressed_vector &v) {
            swap (v);
            return *this;
        }
        template<class AE>
       
        compressed_vector &operator = (const vector_expression<AE> &ae) {
            self_type temporary (ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        compressed_vector &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }


        template<class AE>
       
        compressed_vector &operator += (const vector_expression<AE> &ae) {
            self_type temporary (*this + ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        compressed_vector &operator += (const vector_container<C> &v) {
            plus_assign (v);
            return *this;
        }
        template<class AE>
       
        compressed_vector &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        compressed_vector &operator -= (const vector_expression<AE> &ae) {
            self_type temporary (*this - ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        compressed_vector &operator -= (const vector_container<C> &v) {
            minus_assign (v);
            return *this;
        }
        template<class AE>
       
        compressed_vector &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        compressed_vector &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        compressed_vector &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (compressed_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
                std::swap (capacity_, v.capacity_);
                std::swap (filled_, v.filled_);
                index_data_.swap (v.index_data_);
                value_data_.swap (v.value_data_);
            }
            storage_invariants ();
        }
       
        friend void swap (compressed_vector &v1, compressed_vector &v2) {
            v1.swap (v2);
        }


       
        void push_back (size_type i, const_reference t) {
            if (! (filled_ == 0 || index_data_ [filled_ - 1] < k_based (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1111 << ":" << std::endl; std::cerr << "filled_ == 0 || index_data_ [filled_ - 1] < k_based (i)" << std::endl; external_logic ().raise (); };
            if (filled_ >= capacity_)
                reserve (2 * capacity_, true);
            if (! (filled_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1114 << ":" << std::endl; std::cerr << "filled_ < capacity_" << std::endl; internal_logic ().raise (); };
            index_data_ [filled_] = k_based (i);
            value_data_ [filled_] = t;
            ++ filled_;
            storage_invariants ();
        }
       
        void pop_back () {
            if (! (filled_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1122 << ":" << std::endl; std::cerr << "filled_ > 0" << std::endl; external_logic ().raise (); };
            -- filled_;
            storage_invariants ();
        }


    private:

        typedef typename IA::const_iterator const_subiterator_type;
        typedef typename IA::iterator subiterator_type;

       
        true_reference at_element (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1135 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (! (it != index_data_.begin () + filled_ && *it == k_based (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1137 << ":" << std::endl; std::cerr << "it != index_data_.begin () + filled_ && *it == k_based (i)" << std::endl; bad_index ().raise (); };
            return value_data_ [it - index_data_.begin ()];
        }

    public:
        class const_iterator;
        class iterator;



        const_iterator find (size_type i) const {
            return const_iterator (*this, detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
        }

        iterator find (size_type i) {
            return iterator (*this, detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
        }


        class const_iterator:
            public container_const_reference<compressed_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename compressed_vector::value_type value_type;
            typedef typename compressed_vector::difference_type difference_type;
            typedef typename compressed_vector::const_reference reference;
            typedef const typename compressed_vector::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &v, const const_subiterator_type &it):
                container_const_reference<self_type> (v), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1192 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().value_data_ [it_ - (*this) ().index_data_.begin ()];
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1199 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*this) ().zero_based (*it_) < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1200 << ":" << std::endl; std::cerr << "(*this) ().zero_based (*it_) < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().zero_based (*it_);
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1215 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size_);
        }

        class iterator:
            public container_reference<compressed_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator, value_type> {
        public:
            typedef typename compressed_vector::value_type value_type;
            typedef typename compressed_vector::difference_type difference_type;
            typedef typename compressed_vector::true_reference reference;
            typedef typename compressed_vector::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &v, const subiterator_type &it):
                container_reference<self_type> (v), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1265 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().value_data_ [it_ - (*this) ().index_data_.begin ()];
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1272 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*this) ().zero_based (*it_) < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1273 << ":" << std::endl; std::cerr << "(*this) ().zero_based (*it_) < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().zero_based (*it_);
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1288 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size_);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }


            ar & serialization::make_nvp("capacity", capacity_);
            ar & serialization::make_nvp("filled", filled_);
            ar & serialization::make_nvp("index_data", index_data_);
            ar & serialization::make_nvp("value_data", value_data_);
            storage_invariants();
        }

    private:
        void storage_invariants () const
        {
            if (! (capacity_ == index_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1348 << ":" << std::endl; std::cerr << "capacity_ == index_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == value_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1349 << ":" << std::endl; std::cerr << "capacity_ == value_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (filled_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1350 << ":" << std::endl; std::cerr << "filled_ <= capacity_" << std::endl; internal_logic ().raise (); };
            if (! ((0 == filled_) || (zero_based(index_data_[filled_ - 1]) < size_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1351 << ":" << std::endl; std::cerr << "(0 == filled_) || (zero_based(index_data_[filled_ - 1]) < size_)" << std::endl; internal_logic ().raise (); };
        }

        size_type size_;
        typename index_array_type::size_type capacity_;
        typename index_array_type::size_type filled_;
        index_array_type index_data_;
        value_array_type value_data_;
        static const value_type zero_;

       
        static size_type zero_based (size_type k_based_index) {
            return k_based_index - IB;
        }
       
        static size_type k_based (size_type zero_based_index) {
            return zero_based_index + IB;
        }

        friend class iterator;
        friend class const_iterator;
    };

    template<class T, std::size_t IB, class IA, class TA>
    const typename compressed_vector<T, IB, IA, TA>::value_type compressed_vector<T, IB, IA, TA>::zero_ = value_type ();




    template<class T, std::size_t IB, class IA, class TA>
    class coordinate_vector:
        public vector_container<coordinate_vector<T, IB, IA, TA> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef coordinate_vector<T, IB, IA, TA> self_type;
    public:





        typedef typename IA::value_type size_type;
        typedef typename IA::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;



        typedef sparse_vector_element<self_type> reference;

        typedef IA index_array_type;
        typedef TA value_array_type;
        typedef const vector_reference<const self_type> const_closure_type;
        typedef vector_reference<self_type> closure_type;
        typedef self_type vector_temporary_type;
        typedef sparse_tag storage_category;


       
        coordinate_vector ():
            vector_container<self_type> (),
            size_ (0), capacity_ (restrict_capacity (0)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
        }
        explicit
        coordinate_vector (size_type size, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (size), capacity_ (restrict_capacity (non_zeros)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
        }
       
        coordinate_vector (const coordinate_vector &v):
            vector_container<self_type> (),
            size_ (v.size_), capacity_ (v.capacity_),
            filled_ (v.filled_), sorted_filled_ (v.sorted_filled_), sorted_ (v.sorted_),
            index_data_ (v.index_data_), value_data_ (v.value_data_) {
            storage_invariants ();
        }
        template<class AE>
       
        coordinate_vector (const vector_expression<AE> &ae, size_type non_zeros = 0):
            vector_container<self_type> (),
            size_ (ae ().size ()), capacity_ (restrict_capacity (non_zeros)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
            vector_assign<scalar_assign> (*this, ae);
        }


       
        size_type size () const {
            return size_;
        }
       
        size_type nnz_capacity () const {
            return capacity_;
        }
       
        size_type nnz () const {
            return filled_;
        }


       
        static size_type index_base () {
            return IB;
        }
       
        typename index_array_type::size_type filled () const {
            return filled_;
        }
       
        const index_array_type &index_data () const {
            return index_data_;
        }
       
        const value_array_type &value_data () const {
            return value_data_;
        }
       
        void set_filled (const typename index_array_type::size_type &sorted, const typename index_array_type::size_type &filled) {
            sorted_filled_ = sorted;
            filled_ = filled;
            storage_invariants ();
        }
       
        index_array_type &index_data () {
            return index_data_;
        }
       
        value_array_type &value_data () {
            return value_data_;
        }


    private:
       
        size_type restrict_capacity (size_type non_zeros) const {

             non_zeros = (std::max) (non_zeros, size_type (1));

             return non_zeros;
        }
    public:
       
        void resize (size_type size, bool preserve = true) {
            if (preserve)
                sort ();
            size_ = size;
            capacity_ = restrict_capacity (capacity_);
            if (preserve) {
                index_data_. resize (capacity_, size_type ());
                value_data_. resize (capacity_, value_type ());
                filled_ = (std::min) (capacity_, filled_);
                while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) {
                    --filled_;
                }
            }
            else {
                index_data_. resize (capacity_);
                value_data_. resize (capacity_);
                filled_ = 0;
            }
            sorted_filled_ = filled_;
            storage_invariants ();
        }

       
        void reserve (size_type non_zeros, bool preserve = true) {
            if (preserve)
                sort ();
            capacity_ = restrict_capacity (non_zeros);
            if (preserve) {
                index_data_. resize (capacity_, size_type ());
                value_data_. resize (capacity_, value_type ());
                filled_ = (std::min) (capacity_, filled_);
                }
            else {
                index_data_. resize (capacity_);
                value_data_. resize (capacity_);
                filled_ = 0;
            }
            sorted_filled_ = filled_;
            storage_invariants ();
        }


       
        pointer find_element (size_type i) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
        }
       
        const_pointer find_element (size_type i) const {
            sort ();
            const_subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return 0;
            return &value_data_ [it - index_data_.begin ()];
        }


       
        const_reference operator () (size_type i) const {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1561 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            sort ();
            const_subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return zero_;
            return value_data_ [it - index_data_.begin ()];
        }
       
        true_reference ref (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1570 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            sort ();
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (it == index_data_.begin () + filled_ || *it != k_based (i))
                return insert_element (i, value_type ());
            else
                return value_data_ [it - index_data_.begin ()];
        }
       
        reference operator () (size_type i) {



            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1583 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            return reference (*this, i);

        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }


       
        void append_element (size_type i, const_reference t) {
            if (filled_ >= capacity_)
                reserve (2 * filled_, true);
            if (! (filled_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1602 << ":" << std::endl; std::cerr << "filled_ < capacity_" << std::endl; internal_logic ().raise (); };
            index_data_ [filled_] = k_based (i);
            value_data_ [filled_] = t;
            ++ filled_;
            sorted_ = false;
            storage_invariants ();
        }
       
        true_reference insert_element (size_type i, const_reference t) {
            if (! (!find_element (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1611 << ":" << std::endl; std::cerr << "!find_element (i)" << std::endl; bad_index ().raise (); };
            append_element (i, t);
            return value_data_ [filled_ - 1];
        }
       
        void erase_element (size_type i) {
            sort ();
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            typename std::iterator_traits<subiterator_type>::difference_type n = it - index_data_.begin ();
            if (filled_ > typename index_array_type::size_type (n) && *it == k_based (i)) {
                std::copy (it + 1, index_data_.begin () + filled_, it);
                typename value_array_type::iterator itt (value_data_.begin () + n);
                std::copy (itt + 1, value_data_.begin () + filled_, itt);
                -- filled_;
                sorted_filled_ = filled_;
            }
            storage_invariants ();
        }


       
        void clear () {
            filled_ = 0;
            sorted_filled_ = filled_;
            sorted_ = true;
            storage_invariants ();
        }


       
        coordinate_vector &operator = (const coordinate_vector &v) {
            if (this != &v) {
                size_ = v.size_;
                capacity_ = v.capacity_;
                filled_ = v.filled_;
                sorted_filled_ = v.sorted_filled_;
                sorted_ = v.sorted_;
                index_data_ = v.index_data_;
                value_data_ = v.value_data_;
            }
            storage_invariants ();
            return *this;
        }
        template<class C>
       
        coordinate_vector &operator = (const vector_container<C> &v) {
            resize (v ().size (), false);
            assign (v);
            return *this;
        }
       
        coordinate_vector &assign_temporary (coordinate_vector &v) {
            swap (v);
            return *this;
        }
        template<class AE>
       
        coordinate_vector &operator = (const vector_expression<AE> &ae) {
            self_type temporary (ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        coordinate_vector &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }


        template<class AE>
       
        coordinate_vector &operator += (const vector_expression<AE> &ae) {
            self_type temporary (*this + ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        coordinate_vector &operator += (const vector_container<C> &v) {
            plus_assign (v);
            return *this;
        }
        template<class AE>
       
        coordinate_vector &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        coordinate_vector &operator -= (const vector_expression<AE> &ae) {
            self_type temporary (*this - ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        coordinate_vector &operator -= (const vector_container<C> &v) {
            minus_assign (v);
            return *this;
        }
        template<class AE>
       
        coordinate_vector &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        coordinate_vector &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        coordinate_vector &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (coordinate_vector &v) {
            if (this != &v) {
                std::swap (size_, v.size_);
                std::swap (capacity_, v.capacity_);
                std::swap (filled_, v.filled_);
                std::swap (sorted_filled_, v.sorted_filled_);
                std::swap (sorted_, v.sorted_);
                index_data_.swap (v.index_data_);
                value_data_.swap (v.value_data_);
            }
            storage_invariants ();
        }
       
        friend void swap (coordinate_vector &v1, coordinate_vector &v2) {
            v1.swap (v2);
        }


       
        void sort () const {
            if (! sorted_ && filled_ > 0) {
                typedef index_pair_array<index_array_type, value_array_type> array_pair;
                array_pair ipa (filled_, index_data_, value_data_);
                const typename array_pair::iterator iunsorted = ipa.begin () + sorted_filled_;

                std::sort (iunsorted, ipa.end ());
                std::inplace_merge (ipa.begin (), iunsorted, ipa.end ());


                size_type filled = 0;
                for (size_type i = 1; i < filled_; ++ i) {
                    if (index_data_ [filled] != index_data_ [i]) {
                        ++ filled;
                        if (filled != i) {
                            index_data_ [filled] = index_data_ [i];
                            value_data_ [filled] = value_data_ [i];
                        }
                    } else {
                        value_data_ [filled] += value_data_ [i];
                    }
                }
                filled_ = filled + 1;
                sorted_filled_ = filled_;
                sorted_ = true;
                storage_invariants ();
            }
        }


       
        void push_back (size_type i, const_reference t) {

            if (! (sorted_ && (filled_ == 0 || index_data_ [filled_ - 1] < k_based (i)))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1783 << ":" << std::endl; std::cerr << "sorted_ && (filled_ == 0 || index_data_ [filled_ - 1] < k_based (i))" << std::endl; external_logic ().raise (); };
            if (filled_ >= capacity_)
                reserve (2 * filled_, true);
            if (! (filled_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1786 << ":" << std::endl; std::cerr << "filled_ < capacity_" << std::endl; internal_logic ().raise (); };
            index_data_ [filled_] = k_based (i);
            value_data_ [filled_] = t;
            ++ filled_;
            sorted_filled_ = filled_;
            storage_invariants ();
        }
       
        void pop_back () {

            if (! (filled_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1796 << ":" << std::endl; std::cerr << "filled_ > 0" << std::endl; external_logic ().raise (); };
            -- filled_;
            sorted_filled_ = (std::min) (sorted_filled_, filled_);
            sorted_ = sorted_filled_ = filled_;
            storage_invariants ();
        }


    private:

        typedef typename IA::const_iterator const_subiterator_type;
        typedef typename IA::iterator subiterator_type;

       
        true_reference at_element (size_type i) {
            if (! (i < size_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1811 << ":" << std::endl; std::cerr << "i < size_" << std::endl; bad_index ().raise (); };
            sort ();
            subiterator_type it (detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
            if (! (it != index_data_.begin () + filled_ && *it == k_based (i))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1814 << ":" << std::endl; std::cerr << "it != index_data_.begin () + filled_ && *it == k_based (i)" << std::endl; bad_index ().raise (); };
            return value_data_ [it - index_data_.begin ()];
        }

    public:
        class const_iterator;
        class iterator;



        const_iterator find (size_type i) const {
            sort ();
            return const_iterator (*this, detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
        }

        iterator find (size_type i) {
            sort ();
            return iterator (*this, detail::lower_bound (index_data_.begin (), index_data_.begin () + filled_, k_based (i), std::less<size_type> ()));
        }


        class const_iterator:
            public container_const_reference<coordinate_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator, value_type> {
        public:
            typedef typename coordinate_vector::value_type value_type;
            typedef typename coordinate_vector::difference_type difference_type;
            typedef typename coordinate_vector::const_reference reference;
            typedef const typename coordinate_vector::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &v, const const_subiterator_type &it):
                container_const_reference<self_type> (v), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1871 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().value_data_ [it_ - (*this) ().index_data_.begin ()];
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1878 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*this) ().zero_based (*it_) < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1879 << ":" << std::endl; std::cerr << "(*this) ().zero_based (*it_) < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().zero_based (*it_);
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1894 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            const_subiterator_type it_;
        };

       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size_);
        }

        class iterator:
            public container_reference<coordinate_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator, value_type> {
        public:
            typedef typename coordinate_vector::value_type value_type;
            typedef typename coordinate_vector::difference_type difference_type;
            typedef typename coordinate_vector::true_reference reference;
            typedef typename coordinate_vector::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &v, const subiterator_type &it):
                container_reference<self_type> (v), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }


           
            reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1944 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().value_data_ [it_ - (*this) ().index_data_.begin ()];
            }


           
            size_type index () const {
                if (! (*this != (*this) ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1951 << ":" << std::endl; std::cerr << "*this != (*this) ().end ()" << std::endl; bad_index ().raise (); };
                if (! ((*this) ().zero_based (*it_) < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1952 << ":" << std::endl; std::cerr << "(*this) ().zero_based (*it_) < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return (*this) ().zero_based (*it_);
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 1967 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size_);
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s (size_);
            ar & serialization::make_nvp("size",s);
            if (Archive::is_loading::value) {
                size_ = s;
            }


            ar & serialization::make_nvp("capacity", capacity_);
            ar & serialization::make_nvp("filled", filled_);
            ar & serialization::make_nvp("sorted_filled", sorted_filled_);
            ar & serialization::make_nvp("sorted", sorted_);
            ar & serialization::make_nvp("index_data", index_data_);
            ar & serialization::make_nvp("value_data", value_data_);
            storage_invariants();
        }

    private:
        void storage_invariants () const
        {
            if (! (capacity_ == index_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2029 << ":" << std::endl; std::cerr << "capacity_ == index_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == value_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2030 << ":" << std::endl; std::cerr << "capacity_ == value_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (filled_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2031 << ":" << std::endl; std::cerr << "filled_ <= capacity_" << std::endl; internal_logic ().raise (); };
            if (! (sorted_filled_ <= filled_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2032 << ":" << std::endl; std::cerr << "sorted_filled_ <= filled_" << std::endl; internal_logic ().raise (); };
            if (! (sorted_ == (sorted_filled_ == filled_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2033 << ":" << std::endl; std::cerr << "sorted_ == (sorted_filled_ == filled_)" << std::endl; internal_logic ().raise (); };
            if (! ((0 == filled_) || (zero_based(index_data_[filled_ - 1]) < size_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/vector_sparse.hpp" << " at line " << 2034 << ":" << std::endl; std::cerr << "(0 == filled_) || (zero_based(index_data_[filled_ - 1]) < size_)" << std::endl; internal_logic ().raise (); };
        }

        size_type size_;
        size_type capacity_;
        mutable typename index_array_type::size_type filled_;
        mutable typename index_array_type::size_type sorted_filled_;
        mutable bool sorted_;
        mutable index_array_type index_data_;
        mutable value_array_type value_data_;
        static const value_type zero_;

       
        static size_type zero_based (size_type k_based_index) {
            return k_based_index - IB;
        }
       
        static size_type k_based (size_type zero_based_index) {
            return zero_based_index + IB;
        }

        friend class iterator;
        friend class const_iterator;
    };

    template<class T, std::size_t IB, class IA, class TA>
    const typename coordinate_vector<T, IB, IA, TA>::value_type coordinate_vector<T, IB, IA, TA>::zero_ = value_type ();

}}}
# 17 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" 2
# 25 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp"
namespace boost { namespace numeric { namespace ublas {



    template<class M>
    class sparse_matrix_element:
       public container_reference<M> {
    public:
        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::value_type value_type;
        typedef const value_type &const_reference;
        typedef value_type *pointer;
        typedef const value_type *const_pointer;

    private:

        void get_d () const {
            const_pointer p = (*this) ().find_element (i_, j_);
            if (p)
                d_ = *p;
            else
                d_ = value_type ();
        }

        void set (const value_type &s) const {
            pointer p = (*this) ().find_element (i_, j_);
            if (!p)
                (*this) ().insert_element (i_, j_, s);
            else
                *p = s;
        }

    public:

       
        sparse_matrix_element (matrix_type &m, size_type i, size_type j):
            container_reference<matrix_type> (m), i_ (i), j_ (j) {
        }
       
        sparse_matrix_element (const sparse_matrix_element &p):
            container_reference<matrix_type> (p), i_ (p.i_), j_ (p.j_) {}
       
        ~sparse_matrix_element () {
        }


       
        sparse_matrix_element &operator = (const sparse_matrix_element &p) {

            p.get_d ();
            set (p.d_);
            return *this;
        }
        template<class D>
       
        sparse_matrix_element &operator = (const D &d) {
            set (d);
            return *this;
        }
        template<class D>
       
        sparse_matrix_element &operator += (const D &d) {
            get_d ();
            d_ += d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_matrix_element &operator -= (const D &d) {
            get_d ();
            d_ -= d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_matrix_element &operator *= (const D &d) {
            get_d ();
            d_ *= d;
            set (d_);
            return *this;
        }
        template<class D>
       
        sparse_matrix_element &operator /= (const D &d) {
            get_d ();
            d_ /= d;
            set (d_);
            return *this;
        }


        template<class D>
       
        bool operator == (const D &d) const {
            get_d ();
            return d_ == d;
        }
        template<class D>
       
        bool operator != (const D &d) const {
            get_d ();
            return d_ != d;
        }


       
        operator const_reference () const {
            get_d ();
            return d_;
        }


       
        value_type& ref () const {
            const pointer p = (*this) ().find_element (i_, j_);
            if (!p)
                return (*this) ().insert_element (i_, j_, value_type ());
            else
                return *p;
        }

    private:
        size_type i_;
        size_type j_;
        mutable value_type d_;
    };




    namespace detail {
        template <class V>
        struct element_reference<sparse_matrix_element<V> > {
            typedef typename V::value_type& reference;
            static reference get_reference (const sparse_matrix_element<V>& sve)
            {
                return sve.ref ();
            }
        };
    }


    template<class M>
    struct type_traits<sparse_matrix_element<M> > {
        typedef typename M::value_type element_type;
        typedef type_traits<sparse_matrix_element<M> > self_type;
        typedef typename type_traits<element_type>::value_type value_type;
        typedef typename type_traits<element_type>::const_reference const_reference;
        typedef sparse_matrix_element<M> reference;
        typedef typename type_traits<element_type>::real_type real_type;
        typedef typename type_traits<element_type>::precision_type precision_type;

        static const unsigned plus_complexity = type_traits<element_type>::plus_complexity;
        static const unsigned multiplies_complexity = type_traits<element_type>::multiplies_complexity;

        static
       
        real_type real (const_reference t) {
            return type_traits<element_type>::real (t);
        }
        static
       
        real_type imag (const_reference t) {
            return type_traits<element_type>::imag (t);
        }
        static
       
        value_type conj (const_reference t) {
            return type_traits<element_type>::conj (t);
        }

        static
       
        real_type type_abs (const_reference t) {
            return type_traits<element_type>::type_abs (t);
        }
        static
       
        value_type type_sqrt (const_reference t) {
            return type_traits<element_type>::type_sqrt (t);
        }

        static
       
        real_type norm_1 (const_reference t) {
            return type_traits<element_type>::norm_1 (t);
        }
        static
       
        real_type norm_2 (const_reference t) {
            return type_traits<element_type>::norm_2 (t);
        }
        static
       
        real_type norm_inf (const_reference t) {
            return type_traits<element_type>::norm_inf (t);
        }

        static
       
        bool equals (const_reference t1, const_reference t2) {
            return type_traits<element_type>::equals (t1, t2);
        }
    };

    template<class M1, class T2>
    struct promote_traits<sparse_matrix_element<M1>, T2> {
        typedef typename promote_traits<typename sparse_matrix_element<M1>::value_type, T2>::promote_type promote_type;
    };
    template<class T1, class M2>
    struct promote_traits<T1, sparse_matrix_element<M2> > {
        typedef typename promote_traits<T1, typename sparse_matrix_element<M2>::value_type>::promote_type promote_type;
    };
    template<class M1, class M2>
    struct promote_traits<sparse_matrix_element<M1>, sparse_matrix_element<M2> > {
        typedef typename promote_traits<typename sparse_matrix_element<M1>::value_type,
                                        typename sparse_matrix_element<M2>::value_type>::promote_type promote_type;
    };





    template<class T, class L, class A>
    class mapped_matrix:
        public matrix_container<mapped_matrix<T, L, A> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T * const_pointer;
        typedef L layout_type;
        typedef mapped_matrix<T, L, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef A array_type;
        typedef const T &const_reference;



        typedef sparse_matrix_element<self_type> reference;

        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef mapped_vector<T, A> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef sparse_tag storage_category;
        typedef typename L::orientation_category orientation_category;


       
        mapped_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), data_ () {}
       
        mapped_matrix (size_type size1, size_type size2, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ () {
            detail::map_reserve (data (), restrict_capacity (non_zeros));
        }
       
        mapped_matrix (const mapped_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
        template<class AE>
       
        mapped_matrix (const matrix_expression<AE> &ae, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ () {
            detail::map_reserve (data (), restrict_capacity (non_zeros));
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }
       
        size_type nnz_capacity () const {
            return detail::map_capacity (data ());
        }
       
        size_type nnz () const {
            return data (). size ();
        }


       
        const array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


    private:
       
        size_type restrict_capacity (size_type non_zeros) const {


            if (size1_ > 0 && non_zeros / size1_ >= size2_)
                non_zeros = size1_ * size2_;
            return non_zeros;
        }
    public:
       
        void resize (size_type size1, size_type size2, bool preserve = true) {

            if (! (!preserve)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 347 << ":" << std::endl; std::cerr << "!preserve" << std::endl; internal_logic ().raise (); };
            size1_ = size1;
            size2_ = size2;
            data ().clear ();
        }


       
        void reserve (size_type non_zeros, bool preserve = true) {
            detail::map_reserve (data (), restrict_capacity (non_zeros));
        }


       
        pointer find_element (size_type i, size_type j) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i, j));
        }
       
        const_pointer find_element (size_type i, size_type j) const {
            const size_type element = layout_type::element (i, size1_, j, size2_);
            const_subiterator_type it (data ().find (element));
            if (it == data ().end ())
                return 0;
            if (! ((*it).first == element)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 370 << ":" << std::endl; std::cerr << "(*it).first == element" << std::endl; internal_logic ().raise (); };
            return &(*it).second;
        }


       
        const_reference operator () (size_type i, size_type j) const {
            const size_type element = layout_type::element (i, size1_, j, size2_);
            const_subiterator_type it (data ().find (element));
            if (it == data ().end ())
                return zero_;
            if (! ((*it).first == element)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 381 << ":" << std::endl; std::cerr << "(*it).first == element" << std::endl; internal_logic ().raise (); };
            return (*it).second;
        }
       
        reference operator () (size_type i, size_type j) {






            return reference (*this, i, j);

        }


       
        true_reference insert_element (size_type i, size_type j, const_reference t) {
            if (! (!find_element (i, j))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 399 << ":" << std::endl; std::cerr << "!find_element (i, j)" << std::endl; bad_index ().raise (); };
            const size_type element = layout_type::element (i, size1_, j, size2_);
            std::pair<subiterator_type, bool> ii (data ().insert (typename array_type::value_type (element, t)));
            if (! ((ii.first)->first == element)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 402 << ":" << std::endl; std::cerr << "(ii.first)->first == element" << std::endl; internal_logic ().raise (); };
            if (!ii.second)
                (ii.first)->second = t;
            return (ii.first)->second;
        }
       
        void erase_element (size_type i, size_type j) {
            subiterator_type it = data ().find (layout_type::element (i, size1_, j, size2_));
            if (it == data ().end ())
                return;
            data ().erase (it);
        }


       
        void clear () {
            data ().clear ();
        }


       
        mapped_matrix &operator = (const mapped_matrix &m) {
            if (this != &m) {
                size1_ = m.size1_;
                size2_ = m.size2_;
                data () = m.data ();
            }
            return *this;
        }
        template<class C>
       
        mapped_matrix &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
       
        mapped_matrix &assign_temporary (mapped_matrix &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        mapped_matrix &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae, detail::map_capacity (data ()));
            return assign_temporary (temporary);
        }
        template<class AE>
       
        mapped_matrix &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        mapped_matrix& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae, detail::map_capacity (data ()));
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_matrix &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        mapped_matrix &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        mapped_matrix& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae, detail::map_capacity (data ()));
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_matrix &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        mapped_matrix &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        mapped_matrix& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        mapped_matrix& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (mapped_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                data ().swap (m.data ());
            }
        }
       
        friend void swap (mapped_matrix &m1, mapped_matrix &m2) {
            m1.swap (m2);
        }


    private:

        typedef typename A::const_iterator const_subiterator_type;
        typedef typename A::iterator subiterator_type;

       
        true_reference at_element (size_type i, size_type j) {
            const size_type element = layout_type::element (i, size1_, j, size2_);
            subiterator_type it (data ().find (element));
            if (! (it != data ().end())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 528 << ":" << std::endl; std::cerr << "it != data ().end()" << std::endl; bad_index ().raise (); };
            if (! ((*it).first == element)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 529 << ":" << std::endl; std::cerr << "(*it).first == element" << std::endl; internal_logic ().raise (); };
            return it->second;
        }

    public:
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;



        const_iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) const {
            const_subiterator_type it (data ().lower_bound (layout_type::address (i, size1_, j, size2_)));
            const_subiterator_type it_end (data ().end ());
            size_type index1 = size_type (-1);
            size_type index2 = size_type (-1);
            while (rank == 1 && it != it_end) {
                index1 = layout_type::index_i ((*it).first, size1_, size2_);
                index2 = layout_type::index_j ((*it).first, size1_, size2_);
                if (direction > 0) {
                    if ((index1 >= i && index2 == j) || (i >= size1_))
                        break;
                    ++ i;
                } else {
                    if ((index1 <= i && index2 == j) || (i == 0))
                        break;
                    -- i;
                }
                it = data ().lower_bound (layout_type::address (i, size1_, j, size2_));
            }
            if (rank == 1 && index2 != j) {
                if (direction > 0)
                    i = size1_;
                else
                    i = 0;
                rank = 0;
            }
            return const_iterator1 (*this, rank, i, j, it);
        }

        iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) {
            subiterator_type it (data ().lower_bound (layout_type::address (i, size1_, j, size2_)));
            subiterator_type it_end (data ().end ());
            size_type index1 = size_type (-1);
            size_type index2 = size_type (-1);
            while (rank == 1 && it != it_end) {
                index1 = layout_type::index_i ((*it).first, size1_, size2_);
                index2 = layout_type::index_j ((*it).first, size1_, size2_);
                if (direction > 0) {
                    if ((index1 >= i && index2 == j) || (i >= size1_))
                        break;
                    ++ i;
                } else {
                    if ((index1 <= i && index2 == j) || (i == 0))
                        break;
                    -- i;
                }
                it = data ().lower_bound (layout_type::address (i, size1_, j, size2_));
            }
            if (rank == 1 && index2 != j) {
                if (direction > 0)
                    i = size1_;
                else
                    i = 0;
                rank = 0;
            }
            return iterator1 (*this, rank, i, j, it);
        }

        const_iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) const {
            const_subiterator_type it (data ().lower_bound (layout_type::address (i, size1_, j, size2_)));
            const_subiterator_type it_end (data ().end ());
            size_type index1 = size_type (-1);
            size_type index2 = size_type (-1);
            while (rank == 1 && it != it_end) {
                index1 = layout_type::index_i ((*it).first, size1_, size2_);
                index2 = layout_type::index_j ((*it).first, size1_, size2_);
                if (direction > 0) {
                    if ((index2 >= j && index1 == i) || (j >= size2_))
                        break;
                    ++ j;
                } else {
                    if ((index2 <= j && index1 == i) || (j == 0))
                        break;
                    -- j;
                }
                it = data ().lower_bound (layout_type::address (i, size1_, j, size2_));
            }
            if (rank == 1 && index1 != i) {
                if (direction > 0)
                    j = size2_;
                else
                    j = 0;
                rank = 0;
            }
            return const_iterator2 (*this, rank, i, j, it);
        }

        iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) {
            subiterator_type it (data ().lower_bound (layout_type::address (i, size1_, j, size2_)));
            subiterator_type it_end (data ().end ());
            size_type index1 = size_type (-1);
            size_type index2 = size_type (-1);
            while (rank == 1 && it != it_end) {
                index1 = layout_type::index_i ((*it).first, size1_, size2_);
                index2 = layout_type::index_j ((*it).first, size1_, size2_);
                if (direction > 0) {
                    if ((index2 >= j && index1 == i) || (j >= size2_))
                        break;
                    ++ j;
                } else {
                    if ((index2 <= j && index1 == i) || (j == 0))
                        break;
                    -- j;
                }
                it = data ().lower_bound (layout_type::address (i, size1_, j, size2_));
            }
            if (rank == 1 && index1 != i) {
                if (direction > 0)
                    j = size2_;
                else
                    j = 0;
                rank = 0;
            }
            return iterator2 (*this, rank, i, j, it);
        }


        class const_iterator1:
            public container_const_reference<mapped_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename mapped_matrix::value_type value_type;
            typedef typename mapped_matrix::difference_type difference_type;
            typedef typename mapped_matrix::const_reference reference;
            typedef const typename mapped_matrix::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), it_ () {}
           
            const_iterator1 (const self_type &m, int rank, size_type i, size_type j, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else
                    *this = (*this) ().find1 (rank_, index1 () + 1, j_, 1);
                return *this;
            }
           
            const_iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else
                    *this = (*this) ().find1 (rank_, index1 () - 1, j_, -1);
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 707 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 708 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 752 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 755 << ":" << std::endl; std::cerr << "layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_i ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 765 << ":" << std::endl; std::cerr << "layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_j ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return j_;
                }
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 786 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            const_subiterator_type it_;
        };

       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }

        class iterator1:
            public container_reference<mapped_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename mapped_matrix::value_type value_type;
            typedef typename mapped_matrix::difference_type difference_type;
            typedef typename mapped_matrix::true_reference reference;
            typedef typename mapped_matrix::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), it_ () {}
           
            iterator1 (self_type &m, int rank, size_type i, size_type j, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), it_ (it) {}


           
            iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else
                    *this = (*this) ().find1 (rank_, index1 () + 1, j_, 1);
                return *this;
            }
           
            iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else
                    *this = (*this) ().find1 (rank_, index1 () - 1, j_, -1);
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 853 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 854 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 898 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 901 << ":" << std::endl; std::cerr << "layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_i ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 911 << ":" << std::endl; std::cerr << "layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_j ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return j_;
                }
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 932 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            subiterator_type it_;

            friend class const_iterator1;
        };

       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }

        class const_iterator2:
            public container_const_reference<mapped_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename mapped_matrix::value_type value_type;
            typedef typename mapped_matrix::difference_type difference_type;
            typedef typename mapped_matrix::const_reference reference;
            typedef const typename mapped_matrix::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), it_ () {}
           
            const_iterator2 (const self_type &m, int rank, size_type i, size_type j, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else
                    *this = (*this) ().find2 (rank_, i_, index2 () + 1, 1);
                return *this;
            }
           
            const_iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else
                    *this = (*this) ().find2 (rank_, i_, index2 () - 1, -1);
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1004 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1005 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1051 << ":" << std::endl; std::cerr << "layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_i ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1059 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1062 << ":" << std::endl; std::cerr << "layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_j ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return j_;
                }
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1083 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            const_subiterator_type it_;
        };

       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }

        class iterator2:
            public container_reference<mapped_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename mapped_matrix::value_type value_type;
            typedef typename mapped_matrix::difference_type difference_type;
            typedef typename mapped_matrix::true_reference reference;
            typedef typename mapped_matrix::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), it_ () {}
           
            iterator2 (self_type &m, int rank, size_type i, size_type j, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), it_ (it) {}


           
            iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else
                    *this = (*this) ().find2 (rank_, i_, index2 () + 1, 1);
                return *this;
            }
           
            iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else
                    *this = (*this) ().find2 (rank_, i_, index2 () - 1, -1);
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1150 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1151 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1197 << ":" << std::endl; std::cerr << "layout_type::index_i ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_i ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1205 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    const self_type &m = (*this) ();
                    if (! (layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1208 << ":" << std::endl; std::cerr << "layout_type::index_j ((*it_).first, m.size1 (), m.size2 ()) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_j ((*it_).first, m.size1 (), m.size2 ());
                } else {
                    return j_;
                }
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1229 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            subiterator_type it_;

            friend class const_iterator2;
        };

       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);
            ar & serialization::make_nvp("size1",s1);
            ar & serialization::make_nvp("size2",s2);
            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("data", data_);
        }

    private:
        size_type size1_;
        size_type size2_;
        array_type data_;
        static const value_type zero_;
    };

    template<class T, class L, class A>
    const typename mapped_matrix<T, L, A>::value_type mapped_matrix<T, L, A>::zero_ = value_type ();



    template<class T, class L, class A>
    class mapped_vector_of_mapped_vector:
        public matrix_container<mapped_vector_of_mapped_vector<T, L, A> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef A array_type;
        typedef const A const_array_type;
        typedef L layout_type;
        typedef mapped_vector_of_mapped_vector<T, L, A> self_type;
    public:



        typedef typename A::size_type size_type;
        typedef typename A::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;



        typedef sparse_matrix_element<self_type> reference;

        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef mapped_vector<T, typename A::value_type> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef typename A::value_type::second_type vector_data_value_type;
        typedef sparse_tag storage_category;
        typedef typename L::orientation_category orientation_category;


       
        mapped_vector_of_mapped_vector ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), data_ () {
            data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
        }
       
        mapped_vector_of_mapped_vector (size_type size1, size_type size2, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), data_ () {
            data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
        }
       
        mapped_vector_of_mapped_vector (const mapped_vector_of_mapped_vector &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
        template<class AE>
       
        mapped_vector_of_mapped_vector (const matrix_expression<AE> &ae, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ () {
            data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }
       
        size_type nnz_capacity () const {
            size_type non_zeros = 0;
            for (vector_const_subiterator_type itv = data_ ().begin (); itv != data_ ().end (); ++ itv)
                non_zeros += detail::map_capacity (*itv);
            return non_zeros;
        }
       
        size_type nnz () const {
            size_type filled = 0;
            for (vector_const_subiterator_type itv = data_ ().begin (); itv != data_ ().end (); ++ itv)
                filled += (*itv).size ();
            return filled;
        }


       
        const_array_type &data () const {
            return data_;
        }
       
        array_type &data () {
            return data_;
        }


       
        void resize (size_type size1, size_type size2, bool preserve = true) {

            if (! (!preserve)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1416 << ":" << std::endl; std::cerr << "!preserve" << std::endl; internal_logic ().raise (); };
            size1_ = size1;
            size2_ = size2;
            data ().clear ();
            data () [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
        }


       
        pointer find_element (size_type i, size_type j) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i, j));
        }
       
        const_pointer find_element (size_type i, size_type j) const {
            const size_type element1 = layout_type::index_M (i, j);
            const size_type element2 = layout_type::index_m (i, j);
            vector_const_subiterator_type itv (data ().find (element1));
            if (itv == data ().end ())
                return 0;
            if (! ((*itv).first == element1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1435 << ":" << std::endl; std::cerr << "(*itv).first == element1" << std::endl; internal_logic ().raise (); };
            const_subiterator_type it ((*itv).second.find (element2));
            if (it == (*itv).second.end ())
                return 0;
            if (! ((*it).first == element2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1439 << ":" << std::endl; std::cerr << "(*it).first == element2" << std::endl; internal_logic ().raise (); };
            return &(*it).second;
        }


       
        const_reference operator () (size_type i, size_type j) const {
            const size_type element1 = layout_type::index_M (i, j);
            const size_type element2 = layout_type::index_m (i, j);
            vector_const_subiterator_type itv (data ().find (element1));
            if (itv == data ().end ())
                return zero_;
            if (! ((*itv).first == element1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1451 << ":" << std::endl; std::cerr << "(*itv).first == element1" << std::endl; internal_logic ().raise (); };
            const_subiterator_type it ((*itv).second.find (element2));
            if (it == (*itv).second.end ())
                return zero_;
            if (! ((*itv).first == element1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1455 << ":" << std::endl; std::cerr << "(*itv).first == element1" << std::endl; internal_logic ().raise (); };
            return (*it).second;
        }
       
        reference operator () (size_type i, size_type j) {
# 1468 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp"
            return reference (*this, i, j);

        }


       
        true_reference insert_element (size_type i, size_type j, const_reference t) {
            if (! (!find_element (i, j))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1475 << ":" << std::endl; std::cerr << "!find_element (i, j)" << std::endl; bad_index ().raise (); };
            const size_type element1 = layout_type::index_M (i, j);
            const size_type element2 = layout_type::index_m (i, j);

            vector_data_value_type& vd (data () [element1]);
            std::pair<subiterator_type, bool> ii (vd.insert (typename vector_data_value_type::value_type (element2, t)));
            if (! ((ii.first)->first == element2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1481 << ":" << std::endl; std::cerr << "(ii.first)->first == element2" << std::endl; internal_logic ().raise (); };
            if (!ii.second)
                (ii.first)->second = t;
            return (ii.first)->second;
        }
       
        void erase_element (size_type i, size_type j) {
            vector_subiterator_type itv (data ().find (layout_type::index_M (i, j)));
            if (itv == data ().end ())
                return;
            subiterator_type it ((*itv).second.find (layout_type::index_m (i, j)));
            if (it == (*itv).second.end ())
                return;
            (*itv).second.erase (it);
        }


       
        void clear () {
            data ().clear ();
            data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
        }


       
        mapped_vector_of_mapped_vector &operator = (const mapped_vector_of_mapped_vector &m) {
            if (this != &m) {
                size1_ = m.size1_;
                size2_ = m.size2_;
                data () = m.data ();
            }
            return *this;
        }
        template<class C>
       
        mapped_vector_of_mapped_vector &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 ());
            assign (m);
            return *this;
        }
       
        mapped_vector_of_mapped_vector &assign_temporary (mapped_vector_of_mapped_vector &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_vector_of_mapped_vector &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae);
            return assign_temporary (temporary);
        }
        template<class C>
       
        mapped_vector_of_mapped_vector &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        mapped_vector_of_mapped_vector &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        mapped_vector_of_mapped_vector& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        mapped_vector_of_mapped_vector& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (mapped_vector_of_mapped_vector &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                data ().swap (m.data ());
            }
        }
       
        friend void swap (mapped_vector_of_mapped_vector &m1, mapped_vector_of_mapped_vector &m2) {
            m1.swap (m2);
        }


    private:

        typedef typename A::const_iterator vector_const_subiterator_type;
        typedef typename A::iterator vector_subiterator_type;
        typedef typename A::value_type::second_type::const_iterator const_subiterator_type;
        typedef typename A::value_type::second_type::iterator subiterator_type;

       
        true_reference at_element (size_type i, size_type j) {
            const size_type element1 = layout_type::index_M (i, j);
            const size_type element2 = layout_type::index_m (i, j);
            vector_subiterator_type itv (data ().find (element1));
            if (! (itv != data ().end())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1614 << ":" << std::endl; std::cerr << "itv != data ().end()" << std::endl; bad_index ().raise (); };
            if (! ((*itv).first == element1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1615 << ":" << std::endl; std::cerr << "(*itv).first == element1" << std::endl; internal_logic ().raise (); };
            subiterator_type it ((*itv).second.find (element2));
            if (! (it != (*itv).second.end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1617 << ":" << std::endl; std::cerr << "it != (*itv).second.end ()" << std::endl; bad_index ().raise (); };
            if (! ((*it).first == element2)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1618 << ":" << std::endl; std::cerr << "(*it).first == element2" << std::endl; internal_logic ().raise (); };

            return it->second;
        }

    public:
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;



        const_iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) const {
            if (! (data ().begin () != data ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1636 << ":" << std::endl; std::cerr << "data ().begin () != data ().end ()" << std::endl; internal_logic ().raise (); };
            for (;;) {
                vector_const_subiterator_type itv (data ().lower_bound (layout_type::index_M (i, j)));
                vector_const_subiterator_type itv_end (data ().end ());
                if (itv == itv_end)
                    return const_iterator1 (*this, rank, i, j, itv_end, (*(-- itv)).second.end ());

                const_subiterator_type it ((*itv).second.lower_bound (layout_type::index_m (i, j)));
                const_subiterator_type it_end ((*itv).second.end ());
                if (rank == 0) {

                    size_type M = itv->first;
                    size_type m;
                    if (it != it_end) {
                        m = it->first;
                    } else {
                        m = layout_type::size_m(size1_, size2_);
                    }
                    size_type first_i = layout_type::index_M(M,m);
                    return const_iterator1 (*this, rank, first_i, j, itv, it);
                }
                if (it != it_end && (*it).first == layout_type::index_m (i, j))
                    return const_iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        i = (*it).first;
                    } else {
                        if (i >= size1_)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == (*itv).second.begin ())
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        -- it;
                        i = (*it).first;
                    } else {
                        if (i == 0)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) {
            if (! (data ().begin () != data ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1685 << ":" << std::endl; std::cerr << "data ().begin () != data ().end ()" << std::endl; internal_logic ().raise (); };
            for (;;) {
                vector_subiterator_type itv (data ().lower_bound (layout_type::index_M (i, j)));
                vector_subiterator_type itv_end (data ().end ());
                if (itv == itv_end)
                    return iterator1 (*this, rank, i, j, itv_end, (*(-- itv)).second.end ());

                subiterator_type it ((*itv).second.lower_bound (layout_type::index_m (i, j)));
                subiterator_type it_end ((*itv).second.end ());
                if (rank == 0) {

                    size_type M = itv->first;
                    size_type m;
                    if (it != it_end) {
                        m = it->first;
                    } else {
                        m = layout_type::size_m(size1_, size2_);
                    }
                    size_type first_i = layout_type::index_M(M,m);
                    return iterator1 (*this, rank, first_i, j, itv, it);
                }
                if (it != it_end && (*it).first == layout_type::index_m (i, j))
                    return iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return iterator1 (*this, rank, i, j, itv, it);
                        i = (*it).first;
                    } else {
                        if (i >= size1_)
                            return iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == (*itv).second.begin ())
                            return iterator1 (*this, rank, i, j, itv, it);
                        -- it;
                        i = (*it).first;
                    } else {
                        if (i == 0)
                            return iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        const_iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) const {
            if (! (data ().begin () != data ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1734 << ":" << std::endl; std::cerr << "data ().begin () != data ().end ()" << std::endl; internal_logic ().raise (); };
            for (;;) {
                vector_const_subiterator_type itv (data ().lower_bound (layout_type::index_M (i, j)));
                vector_const_subiterator_type itv_end (data ().end ());
                if (itv == itv_end)
                    return const_iterator2 (*this, rank, i, j, itv_end, (*(-- itv)).second.end ());

                const_subiterator_type it ((*itv).second.lower_bound (layout_type::index_m (i, j)));
                const_subiterator_type it_end ((*itv).second.end ());
                if (rank == 0) {

                    size_type M = itv->first;
                    size_type m;
                    if (it != it_end) {
                        m = it->first;
                    } else {
                        m = layout_type::size_m(size1_, size2_);
                    }
                    size_type first_j = layout_type::index_m(M,m);
                    return const_iterator2 (*this, rank, i, first_j, itv, it);
                }
                if (it != it_end && (*it).first == layout_type::index_m (i, j))
                    return const_iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        j = (*it).first;
                    } else {
                        if (j >= size2_)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == (*itv).second.begin ())
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        -- it;
                        j = (*it).first;
                    } else {
                        if (j == 0)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }

        iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) {
            if (! (data ().begin () != data ().end ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1783 << ":" << std::endl; std::cerr << "data ().begin () != data ().end ()" << std::endl; internal_logic ().raise (); };
            for (;;) {
                vector_subiterator_type itv (data ().lower_bound (layout_type::index_M (i, j)));
                vector_subiterator_type itv_end (data ().end ());
                if (itv == itv_end)
                    return iterator2 (*this, rank, i, j, itv_end, (*(-- itv)).second.end ());

                subiterator_type it ((*itv).second.lower_bound (layout_type::index_m (i, j)));
                subiterator_type it_end ((*itv).second.end ());
                if (rank == 0) {

                    size_type M = itv->first;
                    size_type m;
                    if (it != it_end) {
                        m = it->first;
                    } else {
                        m = layout_type::size_m(size1_, size2_);
                    }
                    size_type first_j = layout_type::index_m(M,m);
                    return iterator2 (*this, rank, i, first_j, itv, it);
                }
                if (it != it_end && (*it).first == layout_type::index_m (i, j))
                    return iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return iterator2 (*this, rank, i, j, itv, it);
                        j = (*it).first;
                    } else {
                        if (j >= size2_)
                            return iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == (*itv).second.begin ())
                            return iterator2 (*this, rank, i, j, itv, it);
                        -- it;
                        j = (*it).first;
                    } else {
                        if (j == 0)
                            return iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }

        class const_iterator1:
            public container_const_reference<mapped_vector_of_mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename mapped_vector_of_mapped_vector::value_type value_type;
            typedef typename mapped_vector_of_mapped_vector::difference_type difference_type;
            typedef typename mapped_vector_of_mapped_vector::const_reference reference;
            typedef const typename mapped_vector_of_mapped_vector::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator1 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type &itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    const self_type &m = (*this) ();
                    if (rank_ == 0) {
                        ++ itv_;
                        i_ = itv_->first;
                    } else {
                        i_ = index1 () + 1;
                    }
                    if (rank_ == 1 && ++ itv_ == m.end1 ().itv_)
                        *this = m.find1 (rank_, i_, j_, 1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index2 () != j_)
                            *this = m.find1 (rank_, i_, j_, 1);
                    }
                }
                return *this;
            }
           
            const_iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    const self_type &m = (*this) ();
                    if (rank_ == 0) {
                        -- itv_;
                        i_ = itv_->first;
                    } else {
                        i_ = index1 () - 1;
                    }

                    if (rank_ == 1 && -- itv_ == m.end1 ().itv_)
                        *this = m.find1 (rank_, i_, j_, -1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index2 () != j_)
                            *this = m.find1 (rank_, i_, j_, -1);
                    }
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1905 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1906 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1950 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1952 << ":" << std::endl; std::cerr << "layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*itv_).first, (*it_).first);
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1961 << ":" << std::endl; std::cerr << "layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*itv_).first, (*it_).first);
                } else {
                    return j_;
                }
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 1983 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }

        class iterator1:
            public container_reference<mapped_vector_of_mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename mapped_vector_of_mapped_vector::value_type value_type;
            typedef typename mapped_vector_of_mapped_vector::difference_type difference_type;
            typedef typename mapped_vector_of_mapped_vector::true_reference reference;
            typedef typename mapped_vector_of_mapped_vector::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator1 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    self_type &m = (*this) ();
                    if (rank_ == 0) {
                        ++ itv_;
                        i_ = itv_->first;
                    } else {
                        i_ = index1 () + 1;
                    }
                    if (rank_ == 1 && ++ itv_ == m.end1 ().itv_)
                        *this = m.find1 (rank_, i_, j_, 1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index2 () != j_)
                            *this = m.find1 (rank_, i_, j_, 1);
                    }
                }
                return *this;
            }
           
            iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    self_type &m = (*this) ();
                    if (rank_ == 0) {
                        -- itv_;
                        i_ = itv_->first;
                    } else {
                        i_ = index1 () - 1;
                    }

                    if (rank_ == 1 && -- itv_ == m.end1 ().itv_)
                        *this = m.find1 (rank_, i_, j_, -1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index2 () != j_)
                            *this = m.find1 (rank_, i_, j_, -1);
                    }
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2080 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2081 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2125 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2127 << ":" << std::endl; std::cerr << "layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*itv_).first, (*it_).first);
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2136 << ":" << std::endl; std::cerr << "layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*itv_).first, (*it_).first);
                } else {
                    return j_;
                }
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2158 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator1;
        };

       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }

        class const_iterator2:
            public container_const_reference<mapped_vector_of_mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename mapped_vector_of_mapped_vector::value_type value_type;
            typedef typename mapped_vector_of_mapped_vector::difference_type difference_type;
            typedef typename mapped_vector_of_mapped_vector::const_reference reference;
            typedef const typename mapped_vector_of_mapped_vector::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator2 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type &itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    const self_type &m = (*this) ();
                    if (rank_ == 0) {
                        ++ itv_;
                        j_ = itv_->first;
                    } else {
                        j_ = index2 () + 1;
                    }
                    if (rank_ == 1 && ++ itv_ == m.end2 ().itv_)
                        *this = m.find2 (rank_, i_, j_, 1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index1 () != i_)
                            *this = m.find2 (rank_, i_, j_, 1);
                    }
                }
                return *this;
            }
           
            const_iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    const self_type &m = (*this) ();
                    if (rank_ == 0) {
                        -- itv_;
                        j_ = itv_->first;
                    } else {
                        j_ = index2 () - 1;
                    }

                    if (rank_ == 1 && -- itv_ == m.end2 ().itv_)
                        *this = m.find2 (rank_, i_, j_, -1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index1 () != i_)
                            *this = m.find2 (rank_, i_, j_, -1);
                    }
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2260 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2261 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2306 << ":" << std::endl; std::cerr << "layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*itv_).first, (*it_).first);
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2314 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2316 << ":" << std::endl; std::cerr << "layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*itv_).first, (*it_).first);
                } else {
                    return j_;
                }
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2338 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }

        class iterator2:
            public container_reference<mapped_vector_of_mapped_vector>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename mapped_vector_of_mapped_vector::value_type value_type;
            typedef typename mapped_vector_of_mapped_vector::difference_type difference_type;
            typedef typename mapped_vector_of_mapped_vector::true_reference reference;
            typedef typename mapped_vector_of_mapped_vector::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator2 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    self_type &m = (*this) ();
                    if (rank_ == 0) {
                        ++ itv_;
                        j_ = itv_->first;
                    } else {
                        j_ = index2 () + 1;
                    }
                    if (rank_ == 1 && ++ itv_ == m.end2 ().itv_)
                        *this = m.find2 (rank_, i_, j_, 1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index1 () != i_)
                            *this = m.find2 (rank_, i_, j_, 1);
                    }
                }
                return *this;
            }
           
            iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    self_type &m = (*this) ();
                    if (rank_ == 0) {
                        -- itv_;
                        j_ = itv_->first;
                    } else {
                        j_ = index2 () - 1;
                    }

                    if (rank_ == 1 && -- itv_ == m.end2 ().itv_)
                        *this = m.find2 (rank_, i_, j_, -1);
                    else if (rank_ == 1) {
                        it_ = (*itv_).second.begin ();
                        if (it_ == (*itv_).second.end () || index1 () != i_)
                            *this = m.find2 (rank_, i_, j_, -1);
                    }
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2435 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2436 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*it_).second;
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2481 << ":" << std::endl; std::cerr << "layout_type::index_M ((*itv_).first, (*it_).first) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*itv_).first, (*it_).first);
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2489 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2491 << ":" << std::endl; std::cerr << "layout_type::index_m ((*itv_).first, (*it_).first) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*itv_).first, (*it_).first);
                } else {
                    return j_;
                }
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2513 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator2;
        };

       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);
            ar & serialization::make_nvp("size1",s1);
            ar & serialization::make_nvp("size2",s2);
            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("data", data_);
        }

    private:
        size_type size1_;
        size_type size2_;
        array_type data_;
        static const value_type zero_;
    };

    template<class T, class L, class A>
    const typename mapped_vector_of_mapped_vector<T, L, A>::value_type mapped_vector_of_mapped_vector<T, L, A>::zero_ = value_type ();




    template<class T, class L, std::size_t IB, class IA, class TA>
    class compressed_matrix:
        public matrix_container<compressed_matrix<T, L, IB, IA, TA> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef L layout_type;
        typedef compressed_matrix<T, L, IB, IA, TA> self_type;
    public:





        typedef typename IA::value_type size_type;

        typedef typename IA::size_type array_size_type;

        typedef typename IA::difference_type difference_type;
        typedef T value_type;
        typedef const T &const_reference;



        typedef sparse_matrix_element<self_type> reference;

        typedef IA index_array_type;
        typedef TA value_array_type;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef compressed_vector<T, IB, IA, TA> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef sparse_tag storage_category;
        typedef typename L::orientation_category orientation_category;


       
        compressed_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), capacity_ (restrict_capacity (0)),
            filled1_ (1), filled2_ (0),
            index1_data_ (layout_type::size_M (size1_, size2_) + 1), index2_data_ (capacity_), value_data_ (capacity_) {
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            storage_invariants ();
        }
       
        compressed_matrix (size_type size1, size_type size2, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)),
            filled1_ (1), filled2_ (0),
            index1_data_ (layout_type::size_M (size1_, size2_) + 1), index2_data_ (capacity_), value_data_ (capacity_) {
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            storage_invariants ();
        }
       
        compressed_matrix (const compressed_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), capacity_ (m.capacity_),
            filled1_ (m.filled1_), filled2_ (m.filled2_),
            index1_data_ (m.index1_data_), index2_data_ (m.index2_data_), value_data_ (m.value_data_) {
            storage_invariants ();
        }

       
        compressed_matrix (const coordinate_matrix<T, L, IB, IA, TA> &m):
            matrix_container<self_type> (),
            size1_ (m.size1()), size2_ (m.size2()),
            index1_data_ (layout_type::size_M (size1_, size2_) + 1)
        {
            m.sort();
            reserve(m.nnz(), false);
            filled2_ = m.nnz();
            const_subiterator_type i_start = m.index1_data().begin();
            const_subiterator_type i_end = (i_start + filled2_);
            const_subiterator_type i = i_start;
            size_type r = 1;
            for (; (r < layout_type::size_M (size1_, size2_)) && (i != i_end); ++r) {
                i = std::lower_bound(i, i_end, r);
                index1_data_[r] = k_based( i - i_start );
            }
            filled1_ = r + 1;
            std::copy( m.index2_data().begin(), m.index2_data().begin() + filled2_, index2_data_.begin());
            std::copy( m.value_data().begin(), m.value_data().begin() + filled2_, value_data_.begin());
            index1_data_ [filled1_ - 1] = k_based(filled2_);
            storage_invariants ();
        }

       template<class AE>
      
       compressed_matrix (const matrix_expression<AE> &ae, size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), capacity_ (restrict_capacity (non_zeros)),
            filled1_ (1), filled2_ (0),
            index1_data_ (layout_type::size_M (ae ().size1 (), ae ().size2 ()) + 1),
            index2_data_ (capacity_), value_data_ (capacity_) {
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            storage_invariants ();
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }
       
        size_type nnz_capacity () const {
            return capacity_;
        }
       
        size_type nnz () const {
            return filled2_;
        }


       
        static size_type index_base () {
            return IB;
        }
       
        array_size_type filled1 () const {
            return filled1_;
        }
       
        array_size_type filled2 () const {
            return filled2_;
        }
       
        const index_array_type &index1_data () const {
            return index1_data_;
        }
       
        const index_array_type &index2_data () const {
            return index2_data_;
        }
       
        const value_array_type &value_data () const {
            return value_data_;
        }
       
        void set_filled (const array_size_type& filled1, const array_size_type& filled2) {
            filled1_ = filled1;
            filled2_ = filled2;
            storage_invariants ();
        }
       
        index_array_type &index1_data () {
            return index1_data_;
        }
       
        index_array_type &index2_data () {
            return index2_data_;
        }
       
        value_array_type &value_data () {
            return value_data_;
        }
       
        void complete_index1_data () {
            while (filled1_ <= layout_type::size_M (size1_, size2_)) {
                this->index1_data_ [filled1_] = k_based (filled2_);
                ++ this->filled1_;
            }
        }


    private:
       
        size_type restrict_capacity (size_type non_zeros) const {
            non_zeros = (std::max) (non_zeros, (std::min) (size1_, size2_));


            if (size1_ > 0 && non_zeros / size1_ >= size2_)
                non_zeros = size1_ * size2_;
            return non_zeros;
        }
    public:
       
        void resize (size_type size1, size_type size2, bool preserve = true) {

            if (! (!preserve)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2791 << ":" << std::endl; std::cerr << "!preserve" << std::endl; internal_logic ().raise (); };
            size1_ = size1;
            size2_ = size2;
            capacity_ = restrict_capacity (capacity_);
            filled1_ = 1;
            filled2_ = 0;
            index1_data_.resize (layout_type::size_M (size1_, size2_) + 1);
            index2_data_.resize (capacity_);
            value_data_.resize (capacity_);
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            storage_invariants ();
        }


       
        void reserve (size_type non_zeros, bool preserve = true) {
            capacity_ = restrict_capacity (non_zeros);
            if (preserve) {
                index2_data_.resize (capacity_, size_type ());
                value_data_.resize (capacity_, value_type ());
                filled2_ = (std::min) (capacity_, filled2_);
            }
            else {
                index2_data_.resize (capacity_);
                value_data_.resize (capacity_);
                filled1_ = 1;
                filled2_ = 0;
                index1_data_ [filled1_ - 1] = k_based (filled2_);
            }
            storage_invariants ();
       }


       
        pointer find_element (size_type i, size_type j) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i, j));
        }
       
        const_pointer find_element (size_type i, size_type j) const {
            size_type element1 (layout_type::index_M (i, j));
            size_type element2 (layout_type::index_m (i, j));
            if (filled1_ <= element1 + 1)
                return 0;
            vector_const_subiterator_type itv (index1_data_.begin () + element1);
            const_subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
            const_subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));
            const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (element2), std::less<size_type> ()));
            if (it == it_end || *it != k_based (element2))
                return 0;
            return &value_data_ [it - index2_data_.begin ()];
        }


       
        const_reference operator () (size_type i, size_type j) const {
            const_pointer p = find_element (i, j);
            if (p)
                return *p;
            else
                return zero_;
        }
       
        reference operator () (size_type i, size_type j) {
# 2865 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp"
            return reference (*this, i, j);

        }


       
        true_reference insert_element (size_type i, size_type j, const_reference t) {
            if (! (!find_element (i, j))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2872 << ":" << std::endl; std::cerr << "!find_element (i, j)" << std::endl; bad_index ().raise (); };
            if (filled2_ >= capacity_)
                reserve (2 * filled2_, true);
            if (! (filled2_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2875 << ":" << std::endl; std::cerr << "filled2_ < capacity_" << std::endl; internal_logic ().raise (); };
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);
            while (filled1_ <= element1 + 1) {
                index1_data_ [filled1_] = k_based (filled2_);
                ++ filled1_;
            }
            vector_subiterator_type itv (index1_data_.begin () + element1);
            subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
            subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));
            subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (element2), std::less<size_type> ()));
            typename std::iterator_traits<subiterator_type>::difference_type n = it - index2_data_.begin ();
            if (! (it == it_end || *it != k_based (element2))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 2887 << ":" << std::endl; std::cerr << "it == it_end || *it != k_based (element2)" << std::endl; internal_logic ().raise (); };
            ++ filled2_;
            it = index2_data_.begin () + n;
            std::copy_backward (it, index2_data_.begin () + filled2_ - 1, index2_data_.begin () + filled2_);
            *it = k_based (element2);
            typename value_array_type::iterator itt (value_data_.begin () + n);
            std::copy_backward (itt, value_data_.begin () + filled2_ - 1, value_data_.begin () + filled2_);
            *itt = t;
            while (element1 + 1 < filled1_) {
                ++ index1_data_ [element1 + 1];
                ++ element1;
            }
            storage_invariants ();
            return *itt;
        }
       
        void erase_element (size_type i, size_type j) {
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);
            if (element1 + 1 >= filled1_)
                return;
            vector_subiterator_type itv (index1_data_.begin () + element1);
            subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
            subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));
            subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (element2), std::less<size_type> ()));
            if (it != it_end && *it == k_based (element2)) {
                typename std::iterator_traits<subiterator_type>::difference_type n = it - index2_data_.begin ();
                std::copy (it + 1, index2_data_.begin () + filled2_, it);
                typename value_array_type::iterator itt (value_data_.begin () + n);
                std::copy (itt + 1, value_data_.begin () + filled2_, itt);
                -- filled2_;
                while (index1_data_ [filled1_ - 2] > k_based (filled2_)) {
                    index1_data_ [filled1_ - 1] = 0;
                    -- filled1_;
                }
                while (element1 + 1 < filled1_) {
                    -- index1_data_ [element1 + 1];
                    ++ element1;
                }
            }
            storage_invariants ();
        }


       
        void clear () {
            filled1_ = 1;
            filled2_ = 0;
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            storage_invariants ();
        }


       
        compressed_matrix &operator = (const compressed_matrix &m) {
            if (this != &m) {
                size1_ = m.size1_;
                size2_ = m.size2_;
                capacity_ = m.capacity_;
                filled1_ = m.filled1_;
                filled2_ = m.filled2_;
                index1_data_ = m.index1_data_;
                index2_data_ = m.index2_data_;
                value_data_ = m.value_data_;
            }
            storage_invariants ();
            return *this;
        }
        template<class C>
       
        compressed_matrix &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
       
        compressed_matrix &assign_temporary (compressed_matrix &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        compressed_matrix &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        compressed_matrix &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        compressed_matrix& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        compressed_matrix &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        compressed_matrix &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        compressed_matrix& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        compressed_matrix &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        compressed_matrix &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        compressed_matrix& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        compressed_matrix& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (compressed_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                std::swap (capacity_, m.capacity_);
                std::swap (filled1_, m.filled1_);
                std::swap (filled2_, m.filled2_);
                index1_data_.swap (m.index1_data_);
                index2_data_.swap (m.index2_data_);
                value_data_.swap (m.value_data_);
            }
            storage_invariants ();
        }
       
        friend void swap (compressed_matrix &m1, compressed_matrix &m2) {
            m1.swap (m2);
        }


       
        void push_back (size_type i, size_type j, const_reference t) {
            if (filled2_ >= capacity_)
                reserve (2 * filled2_, true);
            if (! (filled2_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3053 << ":" << std::endl; std::cerr << "filled2_ < capacity_" << std::endl; internal_logic ().raise (); };
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);
            while (filled1_ < element1 + 2) {
                index1_data_ [filled1_] = k_based (filled2_);
                ++ filled1_;
            }

            if (! ((filled1_ == element1 + 2 && (filled2_ == zero_based (index1_data_ [filled1_ - 2]) || index2_data_ [filled2_ - 1] < k_based (element2))))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3063 << ":" << std::endl; std::cerr << "(filled1_ == element1 + 2 && (filled2_ == zero_based (index1_data_ [filled1_ - 2]) || index2_data_ [filled2_ - 1] < k_based (element2)))" << std::endl; external_logic ().raise (); };


            ++ filled2_;
            index1_data_ [filled1_ - 1] = k_based (filled2_);
            index2_data_ [filled2_ - 1] = k_based (element2);
            value_data_ [filled2_ - 1] = t;
            storage_invariants ();
        }
       
        void pop_back () {
            if (! (filled1_ > 0 && filled2_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3072 << ":" << std::endl; std::cerr << "filled1_ > 0 && filled2_ > 0" << std::endl; external_logic ().raise (); };
            -- filled2_;
            while (index1_data_ [filled1_ - 2] > k_based (filled2_)) {
                index1_data_ [filled1_ - 1] = 0;
                -- filled1_;
            }
            -- index1_data_ [filled1_ - 1];
            storage_invariants ();
        }


    private:

        typedef typename IA::const_iterator vector_const_subiterator_type;
        typedef typename IA::iterator vector_subiterator_type;
        typedef typename IA::const_iterator const_subiterator_type;
        typedef typename IA::iterator subiterator_type;

       
        true_reference at_element (size_type i, size_type j) {
            pointer p = find_element (i, j);
            if (! (p)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3093 << ":" << std::endl; std::cerr << "p" << std::endl; bad_index ().raise (); };
            return *p;
        }

    public:
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;



        const_iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) const {
            for (;;) {
                array_size_type address1 (layout_type::index_M (i, j));
                array_size_type address2 (layout_type::index_m (i, j));
                vector_const_subiterator_type itv (index1_data_.begin () + (std::min) (filled1_ - 1, address1));
                if (filled1_ <= address1 + 1)
                    return const_iterator1 (*this, rank, i, j, itv, index2_data_.begin () + filled2_);

                const_subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
                const_subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));

                const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                if (rank == 0)
                    return const_iterator1 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return const_iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*it);
                    } else {
                        if (i >= size1_)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == index2_data_.begin () + zero_based (*itv))
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*(it - 1));
                    } else {
                        if (i == 0)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) {
            for (;;) {
                array_size_type address1 (layout_type::index_M (i, j));
                array_size_type address2 (layout_type::index_m (i, j));
                vector_subiterator_type itv (index1_data_.begin () + (std::min) (filled1_ - 1, address1));
                if (filled1_ <= address1 + 1)
                    return iterator1 (*this, rank, i, j, itv, index2_data_.begin () + filled2_);

                subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
                subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));

                subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                if (rank == 0)
                    return iterator1 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*it);
                    } else {
                        if (i >= size1_)
                            return iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == index2_data_.begin () + zero_based (*itv))
                            return iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*(it - 1));
                    } else {
                        if (i == 0)
                            return iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        const_iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) const {
            for (;;) {
                array_size_type address1 (layout_type::index_M (i, j));
                array_size_type address2 (layout_type::index_m (i, j));
                vector_const_subiterator_type itv (index1_data_.begin () + (std::min) (filled1_ - 1, address1));
                if (filled1_ <= address1 + 1)
                    return const_iterator2 (*this, rank, i, j, itv, index2_data_.begin () + filled2_);

                const_subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
                const_subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));

                const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                if (rank == 0)
                    return const_iterator2 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return const_iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*it);
                    } else {
                        if (j >= size2_)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == index2_data_.begin () + zero_based (*itv))
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*(it - 1));
                    } else {
                        if (j == 0)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }

        iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) {
            for (;;) {
                array_size_type address1 (layout_type::index_M (i, j));
                array_size_type address2 (layout_type::index_m (i, j));
                vector_subiterator_type itv (index1_data_.begin () + (std::min) (filled1_ - 1, address1));
                if (filled1_ <= address1 + 1)
                    return iterator2 (*this, rank, i, j, itv, index2_data_.begin () + filled2_);

                subiterator_type it_begin (index2_data_.begin () + zero_based (*itv));
                subiterator_type it_end (index2_data_.begin () + zero_based (*(itv + 1)));

                subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                if (rank == 0)
                    return iterator2 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*it);
                    } else {
                        if (j >= size2_)
                            return iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == index2_data_.begin () + zero_based (*itv))
                            return iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*(it - 1));
                    } else {
                        if (j == 0)
                            return iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }


        class const_iterator1:
            public container_const_reference<compressed_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename compressed_matrix::value_type value_type;
            typedef typename compressed_matrix::difference_type difference_type;
            typedef typename compressed_matrix::const_reference reference;
            typedef const typename compressed_matrix::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator1 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type &itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    i_ = index1 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            const_iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    --i_;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3321 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3322 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3366 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3368 << ":" << std::endl; std::cerr << "layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3377 << ":" << std::endl; std::cerr << "layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3399 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }

        class iterator1:
            public container_reference<compressed_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename compressed_matrix::value_type value_type;
            typedef typename compressed_matrix::difference_type difference_type;
            typedef typename compressed_matrix::true_reference reference;
            typedef typename compressed_matrix::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator1 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    i_ = index1 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    --i_;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3473 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3474 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3518 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3520 << ":" << std::endl; std::cerr << "layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3529 << ":" << std::endl; std::cerr << "layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3551 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator1;
        };

       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }

        class const_iterator2:
            public container_const_reference<compressed_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename compressed_matrix::value_type value_type;
            typedef typename compressed_matrix::difference_type difference_type;
            typedef typename compressed_matrix::const_reference reference;
            typedef const typename compressed_matrix::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator2 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    j_ = index2 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            const_iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    --j_;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3630 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3631 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3676 << ":" << std::endl; std::cerr << "layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3684 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3686 << ":" << std::endl; std::cerr << "layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3708 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }

        class iterator2:
            public container_reference<compressed_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename compressed_matrix::value_type value_type;
            typedef typename compressed_matrix::difference_type difference_type;
            typedef typename compressed_matrix::true_reference reference;
            typedef typename compressed_matrix::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator2 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    j_ = index2 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    --j_;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3782 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3783 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3828 << ":" << std::endl; std::cerr << "layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3836 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3838 << ":" << std::endl; std::cerr << "layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m (itv_ - (*this) ().index1_data_.begin (), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3860 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator2;
        };

       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);
            ar & serialization::make_nvp("size1",s1);
            ar & serialization::make_nvp("size2",s2);
            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("capacity", capacity_);
            ar & serialization::make_nvp("filled1", filled1_);
            ar & serialization::make_nvp("filled2", filled2_);
            ar & serialization::make_nvp("index1_data", index1_data_);
            ar & serialization::make_nvp("index2_data", index2_data_);
            ar & serialization::make_nvp("value_data", value_data_);
            storage_invariants();
        }

    private:
        void storage_invariants () const {
            if (! (layout_type::size_M (size1_, size2_) + 1 == index1_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3948 << ":" << std::endl; std::cerr << "layout_type::size_M (size1_, size2_) + 1 == index1_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == index2_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3949 << ":" << std::endl; std::cerr << "capacity_ == index2_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == value_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3950 << ":" << std::endl; std::cerr << "capacity_ == value_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (filled1_ > 0 && filled1_ <= layout_type::size_M (size1_, size2_) + 1)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3951 << ":" << std::endl; std::cerr << "filled1_ > 0 && filled1_ <= layout_type::size_M (size1_, size2_) + 1" << std::endl; internal_logic ().raise (); };
            if (! (filled2_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3952 << ":" << std::endl; std::cerr << "filled2_ <= capacity_" << std::endl; internal_logic ().raise (); };
            if (! (index1_data_ [filled1_ - 1] == k_based (filled2_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 3953 << ":" << std::endl; std::cerr << "index1_data_ [filled1_ - 1] == k_based (filled2_)" << std::endl; internal_logic ().raise (); };
        }

        size_type size1_;
        size_type size2_;
        array_size_type capacity_;
        array_size_type filled1_;
        array_size_type filled2_;
        index_array_type index1_data_;
        index_array_type index2_data_;
        value_array_type value_data_;
        static const value_type zero_;

       
        static size_type zero_based (size_type k_based_index) {
            return k_based_index - IB;
        }
       
        static size_type k_based (size_type zero_based_index) {
            return zero_based_index + IB;
        }

        friend class iterator1;
        friend class iterator2;
        friend class const_iterator1;
        friend class const_iterator2;
    };

    template<class T, class L, std::size_t IB, class IA, class TA>
    const typename compressed_matrix<T, L, IB, IA, TA>::value_type compressed_matrix<T, L, IB, IA, TA>::zero_ = value_type ();




    template<class T, class L, std::size_t IB, class IA, class TA>
    class coordinate_matrix:
        public matrix_container<coordinate_matrix<T, L, IB, IA, TA> > {

        typedef T &true_reference;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef L layout_type;
        typedef coordinate_matrix<T, L, IB, IA, TA> self_type;
    public:




        typedef typename IA::value_type size_type;

        typedef std::ptrdiff_t difference_type;

        typedef typename IA::size_type array_size_type;
        typedef T value_type;
        typedef const T &const_reference;



        typedef sparse_matrix_element<self_type> reference;

        typedef IA index_array_type;
        typedef TA value_array_type;
        typedef const matrix_reference<const self_type> const_closure_type;
        typedef matrix_reference<self_type> closure_type;
        typedef coordinate_vector<T, IB, IA, TA> vector_temporary_type;
        typedef self_type matrix_temporary_type;
        typedef sparse_tag storage_category;
        typedef typename L::orientation_category orientation_category;


       
        coordinate_matrix ():
            matrix_container<self_type> (),
            size1_ (0), size2_ (0), capacity_ (restrict_capacity (0)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index1_data_ (capacity_), index2_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
        }
       
        coordinate_matrix (size_type size1, size_type size2, array_size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index1_data_ (capacity_), index2_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
        }
       
        coordinate_matrix (const coordinate_matrix &m):
            matrix_container<self_type> (),
            size1_ (m.size1_), size2_ (m.size2_), capacity_ (m.capacity_),
            filled_ (m.filled_), sorted_filled_ (m.sorted_filled_), sorted_ (m.sorted_),
            index1_data_ (m.index1_data_), index2_data_ (m.index2_data_), value_data_ (m.value_data_) {
            storage_invariants ();
        }
        template<class AE>
       
        coordinate_matrix (const matrix_expression<AE> &ae, array_size_type non_zeros = 0):
            matrix_container<self_type> (),
            size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), capacity_ (restrict_capacity (non_zeros)),
            filled_ (0), sorted_filled_ (filled_), sorted_ (true),
            index1_data_ (capacity_), index2_data_ (capacity_), value_data_ (capacity_) {
            storage_invariants ();
            matrix_assign<scalar_assign> (*this, ae);
        }


       
        size_type size1 () const {
            return size1_;
        }
       
        size_type size2 () const {
            return size2_;
        }
       
        size_type nnz_capacity () const {
            return capacity_;
        }
       
        size_type nnz () const {
            return filled_;
        }


       
        static size_type index_base () {
            return IB;
        }
       
        array_size_type filled () const {
            return filled_;
        }
       
        const index_array_type &index1_data () const {
            return index1_data_;
        }
       
        const index_array_type &index2_data () const {
            return index2_data_;
        }
       
        const value_array_type &value_data () const {
            return value_data_;
        }
       
        void set_filled (const array_size_type &filled) {

            if (sorted_ && filled < filled_)
                sorted_filled_ = filled;
            else
                sorted_ = (sorted_filled_ == filled);
            filled_ = filled;
            storage_invariants ();
        }
       
        index_array_type &index1_data () {
            return index1_data_;
        }
       
        index_array_type &index2_data () {
            return index2_data_;
        }
       
        value_array_type &value_data () {
            return value_data_;
        }


    private:
       
        array_size_type restrict_capacity (array_size_type non_zeros) const {

            non_zeros = (std::max) (non_zeros, array_size_type((std::min) (size1_, size2_)));

            return non_zeros;
        }
    public:
       
        void resize (size_type size1, size_type size2, bool preserve = true) {

            if (! (!preserve)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4133 << ":" << std::endl; std::cerr << "!preserve" << std::endl; internal_logic ().raise (); };
            size1_ = size1;
            size2_ = size2;
            capacity_ = restrict_capacity (capacity_);
            index1_data_.resize (capacity_);
            index2_data_.resize (capacity_);
            value_data_.resize (capacity_);
            filled_ = 0;
            sorted_filled_ = filled_;
            sorted_ = true;
            storage_invariants ();
        }


       
        void reserve (array_size_type non_zeros, bool preserve = true) {
            sort ();
            capacity_ = restrict_capacity (non_zeros);
            if (preserve) {
                index1_data_.resize (capacity_, size_type ());
                index2_data_.resize (capacity_, size_type ());
                value_data_.resize (capacity_, value_type ());
                filled_ = (std::min) (capacity_, filled_);
            }
            else {
                index1_data_.resize (capacity_);
                index2_data_.resize (capacity_);
                value_data_.resize (capacity_);
                filled_ = 0;
            }
            sorted_filled_ = filled_;
            storage_invariants ();
        }


       
        pointer find_element (size_type i, size_type j) {
            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i, j));
        }
       
        const_pointer find_element (size_type i, size_type j) const {
            sort ();
            size_type element1 (layout_type::index_M (i, j));
            size_type element2 (layout_type::index_m (i, j));
            vector_const_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (element1), std::less<size_type> ()));
            vector_const_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (element1), std::less<size_type> ()));
            if (itv_begin == itv_end)
                return 0;
            const_subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
            const_subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));
            const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (element2), std::less<size_type> ()));
            if (it == it_end || *it != k_based (element2))
                return 0;
            return &value_data_ [it - index2_data_.begin ()];
        }


       
        const_reference operator () (size_type i, size_type j) const {
            const_pointer p = find_element (i, j);
            if (p)
                return *p;
            else
                return zero_;
        }
       
        reference operator () (size_type i, size_type j) {







            return reference (*this, i, j);

        }


       
        void append_element (size_type i, size_type j, const_reference t) {
            if (filled_ >= capacity_)
                reserve (2 * filled_, true);
            if (! (filled_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4216 << ":" << std::endl; std::cerr << "filled_ < capacity_" << std::endl; internal_logic ().raise (); };
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);
            index1_data_ [filled_] = k_based (element1);
            index2_data_ [filled_] = k_based (element2);
            value_data_ [filled_] = t;
            ++ filled_;
            sorted_ = false;
            storage_invariants ();
        }
       
        true_reference insert_element (size_type i, size_type j, const_reference t) {
            if (! (!find_element (i, j))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4228 << ":" << std::endl; std::cerr << "!find_element (i, j)" << std::endl; bad_index ().raise (); };
            append_element (i, j, t);
            return value_data_ [filled_ - 1];
        }
       
        void erase_element (size_type i, size_type j) {
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);
            sort ();
            vector_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (element1), std::less<size_type> ()));
            vector_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (element1), std::less<size_type> ()));
            subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
            subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));
            subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (element2), std::less<size_type> ()));
            if (it != it_end && *it == k_based (element2)) {
                typename std::iterator_traits<subiterator_type>::difference_type n = it - index2_data_.begin ();
                vector_subiterator_type itv (index1_data_.begin () + n);
                std::copy (itv + 1, index1_data_.begin () + filled_, itv);
                std::copy (it + 1, index2_data_.begin () + filled_, it);
                typename value_array_type::iterator itt (value_data_.begin () + n);
                std::copy (itt + 1, value_data_.begin () + filled_, itt);
                -- filled_;
                sorted_filled_ = filled_;
            }
            storage_invariants ();
        }


       
        void clear () {
            filled_ = 0;
            sorted_filled_ = filled_;
            sorted_ = true;
            storage_invariants ();
        }


       
        coordinate_matrix &operator = (const coordinate_matrix &m) {
            if (this != &m) {
                size1_ = m.size1_;
                size2_ = m.size2_;
                capacity_ = m.capacity_;
                filled_ = m.filled_;
                sorted_filled_ = m.sorted_filled_;
                sorted_ = m.sorted_;
                index1_data_ = m.index1_data_;
                index2_data_ = m.index2_data_;
                value_data_ = m.value_data_;
                if (! (capacity_ == index1_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4277 << ":" << std::endl; std::cerr << "capacity_ == index1_data_.size ()" << std::endl; internal_logic ().raise (); };
                if (! (capacity_ == index2_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4278 << ":" << std::endl; std::cerr << "capacity_ == index2_data_.size ()" << std::endl; internal_logic ().raise (); };
                if (! (capacity_ == value_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4279 << ":" << std::endl; std::cerr << "capacity_ == value_data_.size ()" << std::endl; internal_logic ().raise (); };
            }
            storage_invariants ();
            return *this;
        }
        template<class C>
       
        coordinate_matrix &operator = (const matrix_container<C> &m) {
            resize (m ().size1 (), m ().size2 (), false);
            assign (m);
            return *this;
        }
       
        coordinate_matrix &assign_temporary (coordinate_matrix &m) {
            swap (m);
            return *this;
        }
        template<class AE>
       
        coordinate_matrix &operator = (const matrix_expression<AE> &ae) {
            self_type temporary (ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class AE>
       
        coordinate_matrix &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        coordinate_matrix& operator += (const matrix_expression<AE> &ae) {
            self_type temporary (*this + ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        coordinate_matrix &operator += (const matrix_container<C> &m) {
            plus_assign (m);
            return *this;
        }
        template<class AE>
       
        coordinate_matrix &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        coordinate_matrix& operator -= (const matrix_expression<AE> &ae) {
            self_type temporary (*this - ae, capacity_);
            return assign_temporary (temporary);
        }
        template<class C>
       
        coordinate_matrix &operator -= (const matrix_container<C> &m) {
            minus_assign (m);
            return *this;
        }
        template<class AE>
       
        coordinate_matrix &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        coordinate_matrix& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        coordinate_matrix& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        void swap (coordinate_matrix &m) {
            if (this != &m) {
                std::swap (size1_, m.size1_);
                std::swap (size2_, m.size2_);
                std::swap (capacity_, m.capacity_);
                std::swap (filled_, m.filled_);
                std::swap (sorted_filled_, m.sorted_filled_);
                std::swap (sorted_, m.sorted_);
                index1_data_.swap (m.index1_data_);
                index2_data_.swap (m.index2_data_);
                value_data_.swap (m.value_data_);
            }
            storage_invariants ();
        }
       
        friend void swap (coordinate_matrix &m1, coordinate_matrix &m2) {
            m1.swap (m2);
        }


       
        void sort () const {
            if (! sorted_ && filled_ > 0) {
                typedef index_triple_array<index_array_type, index_array_type, value_array_type> array_triple;
                array_triple ita (filled_, index1_data_, index2_data_, value_data_);
                const typename array_triple::iterator iunsorted = ita.begin () + sorted_filled_;

                std::sort (iunsorted, ita.end ());
                std::inplace_merge (ita.begin (), iunsorted, ita.end ());


                array_size_type filled = 0;
                for (array_size_type i = 1; i < filled_; ++ i) {
                    if (index1_data_ [filled] != index1_data_ [i] ||
                        index2_data_ [filled] != index2_data_ [i]) {
                        ++ filled;
                        if (filled != i) {
                            index1_data_ [filled] = index1_data_ [i];
                            index2_data_ [filled] = index2_data_ [i];
                            value_data_ [filled] = value_data_ [i];
                        }
                    } else {
                        value_data_ [filled] += value_data_ [i];
                    }
                }
                filled_ = filled + 1;
                sorted_filled_ = filled_;
                sorted_ = true;
                storage_invariants ();
            }
        }


       
        void push_back (size_type i, size_type j, const_reference t) {
            size_type element1 = layout_type::index_M (i, j);
            size_type element2 = layout_type::index_m (i, j);

            if (! (sorted_ && (filled_ == 0 || index1_data_ [filled_ - 1] < k_based (element1) || (index1_data_ [filled_ - 1] == k_based (element1) && index2_data_ [filled_ - 1] < k_based (element2))))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4421 << ":" << std::endl; std::cerr << "sorted_ && (filled_ == 0 || index1_data_ [filled_ - 1] < k_based (element1) || (index1_data_ [filled_ - 1] == k_based (element1) && index2_data_ [filled_ - 1] < k_based (element2)))" << std::endl; external_logic ().raise (); };




            if (filled_ >= capacity_)
                reserve (2 * filled_, true);
            if (! (filled_ < capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4424 << ":" << std::endl; std::cerr << "filled_ < capacity_" << std::endl; internal_logic ().raise (); };
            index1_data_ [filled_] = k_based (element1);
            index2_data_ [filled_] = k_based (element2);
            value_data_ [filled_] = t;
            ++ filled_;
            sorted_filled_ = filled_;
            storage_invariants ();
        }
       
        void pop_back () {

            if (! (filled_ > 0)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4435 << ":" << std::endl; std::cerr << "filled_ > 0" << std::endl; external_logic ().raise (); };
            -- filled_;
            sorted_filled_ = (std::min) (sorted_filled_, filled_);
            sorted_ = sorted_filled_ = filled_;
            storage_invariants ();
        }


    private:

        typedef typename IA::const_iterator vector_const_subiterator_type;
        typedef typename IA::iterator vector_subiterator_type;
        typedef typename IA::const_iterator const_subiterator_type;
        typedef typename IA::iterator subiterator_type;

       
        true_reference at_element (size_type i, size_type j) {
            pointer p = find_element (i, j);
            if (! (p)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4453 << ":" << std::endl; std::cerr << "p" << std::endl; bad_index ().raise (); };
            return *p;
        }

    public:
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;
        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;



        const_iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) const {
            sort ();
            for (;;) {
                size_type address1 (layout_type::index_M (i, j));
                size_type address2 (layout_type::index_m (i, j));
                vector_const_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));
                vector_const_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));

                const_subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
                const_subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));

                const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                vector_const_subiterator_type itv (index1_data_.begin () + (it - index2_data_.begin ()));
                if (rank == 0)
                    return const_iterator1 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return const_iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*it);
                    } else {
                        if (i >= size1_)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == index2_data_.begin () + array_size_type (zero_based (*itv)))
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*(it - 1));
                    } else {
                        if (i == 0)
                            return const_iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        iterator1 find1 (int rank, size_type i, size_type j, int direction = 1) {
            sort ();
            for (;;) {
                size_type address1 (layout_type::index_M (i, j));
                size_type address2 (layout_type::index_m (i, j));
                vector_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));
                vector_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));

                subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
                subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));

                subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                vector_subiterator_type itv (index1_data_.begin () + (it - index2_data_.begin ()));
                if (rank == 0)
                    return iterator1 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return iterator1 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_i ()) {
                        if (it == it_end)
                            return iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*it);
                    } else {
                        if (i >= size1_)
                            return iterator1 (*this, rank, i, j, itv, it);
                        ++ i;
                    }
                } else {
                    if (layout_type::fast_i ()) {
                        if (it == index2_data_.begin () + array_size_type (zero_based (*itv)))
                            return iterator1 (*this, rank, i, j, itv, it);
                        i = zero_based (*(it - 1));
                    } else {
                        if (i == 0)
                            return iterator1 (*this, rank, i, j, itv, it);
                        -- i;
                    }
                }
            }
        }

        const_iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) const {
            sort ();
            for (;;) {
                size_type address1 (layout_type::index_M (i, j));
                size_type address2 (layout_type::index_m (i, j));
                vector_const_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));
                vector_const_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));

                const_subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
                const_subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));

                const_subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                vector_const_subiterator_type itv (index1_data_.begin () + (it - index2_data_.begin ()));
                if (rank == 0)
                    return const_iterator2 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return const_iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*it);
                    } else {
                        if (j >= size2_)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == index2_data_.begin () + array_size_type (zero_based (*itv)))
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*(it - 1));
                    } else {
                        if (j == 0)
                            return const_iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }

        iterator2 find2 (int rank, size_type i, size_type j, int direction = 1) {
            sort ();
            for (;;) {
                size_type address1 (layout_type::index_M (i, j));
                size_type address2 (layout_type::index_m (i, j));
                vector_subiterator_type itv_begin (detail::lower_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));
                vector_subiterator_type itv_end (detail::upper_bound (index1_data_.begin (), index1_data_.begin () + filled_, k_based (address1), std::less<size_type> ()));

                subiterator_type it_begin (index2_data_.begin () + (itv_begin - index1_data_.begin ()));
                subiterator_type it_end (index2_data_.begin () + (itv_end - index1_data_.begin ()));

                subiterator_type it (detail::lower_bound (it_begin, it_end, k_based (address2), std::less<size_type> ()));
                vector_subiterator_type itv (index1_data_.begin () + (it - index2_data_.begin ()));
                if (rank == 0)
                    return iterator2 (*this, rank, i, j, itv, it);
                if (it != it_end && zero_based (*it) == address2)
                    return iterator2 (*this, rank, i, j, itv, it);
                if (direction > 0) {
                    if (layout_type::fast_j ()) {
                        if (it == it_end)
                            return iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*it);
                    } else {
                        if (j >= size2_)
                            return iterator2 (*this, rank, i, j, itv, it);
                        ++ j;
                    }
                } else {
                    if (layout_type::fast_j ()) {
                        if (it == index2_data_.begin () + array_size_type (zero_based (*itv)))
                            return iterator2 (*this, rank, i, j, itv, it);
                        j = zero_based (*(it - 1));
                    } else {
                        if (j == 0)
                            return iterator2 (*this, rank, i, j, itv, it);
                        -- j;
                    }
                }
            }
        }


        class const_iterator1:
            public container_const_reference<coordinate_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator1, value_type> {
        public:
            typedef typename coordinate_matrix::value_type value_type;
            typedef typename coordinate_matrix::difference_type difference_type;
            typedef typename coordinate_matrix::const_reference reference;
            typedef const typename coordinate_matrix::pointer pointer;

            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator1 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type &itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    i_ = index1 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            const_iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    i_ = index1 () - 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4685 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4686 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator2 begin () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4730 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4732 << ":" << std::endl; std::cerr << "layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4741 << ":" << std::endl; std::cerr << "layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4763 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1_, 0);
        }

        class iterator1:
            public container_reference<coordinate_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator1, value_type> {
        public:
            typedef typename coordinate_matrix::value_type value_type;
            typedef typename coordinate_matrix::difference_type difference_type;
            typedef typename coordinate_matrix::true_reference reference;
            typedef typename coordinate_matrix::pointer pointer;

            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator1 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator1 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_i ())
                    ++ it_;
                else {
                    i_ = index1 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            iterator1 &operator -- () {
                if (rank_ == 1 && layout_type::fast_i ())
                    -- it_;
                else {
                    i_ = index1 () - 1;
                    if (rank_ == 1)
                        *this = (*this) ().find1 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4837 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4838 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator2 begin () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &m = (*this) ();
                return m.find2 (1, index1 (), m.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                if (! (*this != (*this) ().find1 (0, (*this) ().size1 (), j_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4882 << ":" << std::endl; std::cerr << "*this != (*this) ().find1 (0, (*this) ().size1 (), j_)" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4884 << ":" << std::endl; std::cerr << "layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4893 << ":" << std::endl; std::cerr << "layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4915 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator1;
        };

       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1_, 0);
        }

        class const_iterator2:
            public container_const_reference<coordinate_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               const_iterator2, value_type> {
        public:
            typedef typename coordinate_matrix::value_type value_type;
            typedef typename coordinate_matrix::difference_type difference_type;
            typedef typename coordinate_matrix::const_reference reference;
            typedef const typename coordinate_matrix::pointer pointer;

            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            const_iterator2 (const self_type &m, int rank, size_type i, size_type j, const vector_const_subiterator_type itv, const const_subiterator_type &it):
                container_const_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), rank_ (it.rank_), i_ (it.i_), j_ (it.j_), itv_ (it.itv_), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    j_ = index2 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            const_iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    j_ = index2 () - 1;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            const_reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4994 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 4995 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) () (i_, j_);
                }
            }


           



            const_iterator1 begin () const {
                const self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5040 << ":" << std::endl; std::cerr << "layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5048 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5050 << ":" << std::endl; std::cerr << "layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5072 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_const_subiterator_type itv_;
            const_subiterator_type it_;
        };

       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2_);
        }

        class iterator2:
            public container_reference<coordinate_matrix>,
            public bidirectional_iterator_base<sparse_bidirectional_iterator_tag,
                                               iterator2, value_type> {
        public:
            typedef typename coordinate_matrix::value_type value_type;
            typedef typename coordinate_matrix::difference_type difference_type;
            typedef typename coordinate_matrix::true_reference reference;
            typedef typename coordinate_matrix::pointer pointer;

            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), rank_ (), i_ (), j_ (), itv_ (), it_ () {}
           
            iterator2 (self_type &m, int rank, size_type i, size_type j, const vector_subiterator_type &itv, const subiterator_type &it):
                container_reference<self_type> (m), rank_ (rank), i_ (i), j_ (j), itv_ (itv), it_ (it) {}


           
            iterator2 &operator ++ () {
                if (rank_ == 1 && layout_type::fast_j ())
                    ++ it_;
                else {
                    j_ = index2 () + 1;
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, 1);
                }
                return *this;
            }
           
            iterator2 &operator -- () {
                if (rank_ == 1 && layout_type::fast_j ())
                    -- it_;
                else {
                    j_ = index2 ();
                    if (rank_ == 1)
                        *this = (*this) ().find2 (rank_, i_, j_, -1);
                }
                return *this;
            }


           
            reference operator * () const {
                if (! (index1 () < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5146 << ":" << std::endl; std::cerr << "index1 () < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                if (! (index2 () < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5147 << ":" << std::endl; std::cerr << "index2 () < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    return (*this) ().value_data_ [it_ - (*this) ().index2_data_.begin ()];
                } else {
                    return (*this) ().at_element (i_, j_);
                }
            }


           



            iterator1 begin () const {
                self_type &m = (*this) ();
                return m.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &m = (*this) ();
                return m.find1 (1, m.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                if (rank_ == 1) {
                    if (! (layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5192 << ":" << std::endl; std::cerr << "layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size1 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_M ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return i_;
                }
            }
           
            size_type index2 () const {
                if (! (*this != (*this) ().find2 (0, i_, (*this) ().size2 ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5200 << ":" << std::endl; std::cerr << "*this != (*this) ().find2 (0, i_, (*this) ().size2 ())" << std::endl; bad_index ().raise (); };
                if (rank_ == 1) {
                    if (! (layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5202 << ":" << std::endl; std::cerr << "layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_)) < (*this) ().size2 ()" << std::endl; bad_index ().raise (); };
                    return layout_type::index_m ((*this) ().zero_based (*itv_), (*this) ().zero_based (*it_));
                } else {
                    return j_;
                }
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                rank_ = it.rank_;
                i_ = it.i_;
                j_ = it.j_;
                itv_ = it.itv_;
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! (&(*this) () == &it ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5224 << ":" << std::endl; std::cerr << "&(*this) () == &it ()" << std::endl; external_logic ().raise (); };

                if (rank_ == 1 || it.rank_ == 1) {
                    return it_ == it.it_;
                } else {
                    return i_ == it.i_ && j_ == it.j_;
                }
            }

        private:
            int rank_;
            size_type i_;
            size_type j_;
            vector_subiterator_type itv_;
            subiterator_type it_;

            friend class const_iterator2;
        };

       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2_);
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }


        template<class Archive>
        void serialize(Archive & ar, const unsigned int ){
            serialization::collection_size_type s1 (size1_);
            serialization::collection_size_type s2 (size2_);
            ar & serialization::make_nvp("size1",s1);
            ar & serialization::make_nvp("size2",s2);
            if (Archive::is_loading::value) {
                size1_ = s1;
                size2_ = s2;
            }
            ar & serialization::make_nvp("capacity", capacity_);
            ar & serialization::make_nvp("filled", filled_);
            ar & serialization::make_nvp("sorted_filled", sorted_filled_);
            ar & serialization::make_nvp("sorted", sorted_);
            ar & serialization::make_nvp("index1_data", index1_data_);
            ar & serialization::make_nvp("index2_data", index2_data_);
            ar & serialization::make_nvp("value_data", value_data_);
            storage_invariants();
        }

    private:
        void storage_invariants () const
        {
            if (! (capacity_ == index1_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5314 << ":" << std::endl; std::cerr << "capacity_ == index1_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == index2_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5315 << ":" << std::endl; std::cerr << "capacity_ == index2_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (capacity_ == value_data_.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5316 << ":" << std::endl; std::cerr << "capacity_ == value_data_.size ()" << std::endl; internal_logic ().raise (); };
            if (! (filled_ <= capacity_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5317 << ":" << std::endl; std::cerr << "filled_ <= capacity_" << std::endl; internal_logic ().raise (); };
            if (! (sorted_filled_ <= filled_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5318 << ":" << std::endl; std::cerr << "sorted_filled_ <= filled_" << std::endl; internal_logic ().raise (); };
            if (! (sorted_ == (sorted_filled_ == filled_))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_sparse.hpp" << " at line " << 5319 << ":" << std::endl; std::cerr << "sorted_ == (sorted_filled_ == filled_)" << std::endl; internal_logic ().raise (); };
        }

        size_type size1_;
        size_type size2_;
        array_size_type capacity_;
        mutable array_size_type filled_;
        mutable array_size_type sorted_filled_;
        mutable bool sorted_;
        mutable index_array_type index1_data_;
        mutable index_array_type index2_data_;
        mutable value_array_type value_data_;
        static const value_type zero_;

       
        static size_type zero_based (size_type k_based_index) {
            return k_based_index - IB;
        }
       
        static size_type k_based (size_type zero_based_index) {
            return zero_based_index + IB;
        }

        friend class iterator1;
        friend class iterator2;
        friend class const_iterator1;
        friend class const_iterator2;
    };

    template<class T, class L, std::size_t IB, class IA, class TA>
    const typename coordinate_matrix<T, L, IB, IA, TA>::value_type coordinate_matrix<T, L, IB, IA, TA>::zero_ = value_type ();

}}}
# 14 "/home/preben/working/CRTPlanner/MechSystem.hpp" 2



namespace rw { namespace dynamics {
# 31 "/home/preben/working/CRTPlanner/MechSystem.hpp"
    template <typename T = double>
    class MechSystem {
    public:




        MechSystem() { };
# 50 "/home/preben/working/CRTPlanner/MechSystem.hpp"
        virtual ~MechSystem() { };


        unsigned int noCoordinates() const { return _N; }
        unsigned int noConstraints() const { return _M; };

        boost::numeric::ublas::vector<T>& initialCoordinates() { return _q0; }
        const boost::numeric::ublas::vector<T>& initialCoordinates() const { return _q0; };
        boost::numeric::ublas::vector<T>& initialVelocities() { return _v0; };
        const boost::numeric::ublas::vector<T>& initialVelocities() const { return _v0; };





        virtual boost::numeric::ublas::vector<T> constraints(const boost::numeric::ublas::vector<T>& q) const {
            boost::numeric::ublas::vector<T> G(this->_constraints.size());


            for (unsigned int i = 0; i < this->_constraints.size(); ++i) {
                G(i) = this->_constraints.at(i)->evaluate(q);
            }

            return G;
        }

        virtual boost::numeric::ublas::compressed_matrix<T> dConstraints(const boost::numeric::ublas::vector<T>& q) const {
            boost::numeric::ublas::compressed_matrix<T> dG(this->_M, this->_N);


            for (unsigned int i = 0; i < this->_N; ++i) {
                for (unsigned int j = 0; j < this->_clist[i].size(); ++j) {
                    unsigned int alpha = this->_clist[i][j];
                    dG(alpha,i) = this->_constraints[alpha]->dG(i, q);
                }
            }

            return dG;
        }

        virtual std::vector<boost::numeric::ublas::matrix<T> > ddConstraints(const boost::numeric::ublas::vector<T>& q) const {
            std::vector<boost::numeric::ublas::matrix<T> > ddG(this->_M);

            boost::numeric::ublas::matrix<T> item(this->_N, this->_N);

            for (unsigned int i = 0; i < this->_N; ++i) {
                for (unsigned int j = 0; j < this->_N; ++j) {
                    item(i,j) = 0;
                }
            }

            for (unsigned int alpha = 0; alpha < this->_M; ++alpha) {
                ddG[alpha] = item;
            }


            for (unsigned int i = 0; i < _N; ++i) {
                for (unsigned int k = 0; k < this->_clist[i].size(); ++k) {
                    unsigned int alpha = this->_clist[i][k];

                    std::vector<unsigned int> c = this->_constraints[alpha]->getDependencies();
                    for (unsigned int l = 0; l < c.size(); ++l) {
                        unsigned int j = c[l];
                        ddG[alpha](i,j) = this->_constraints[alpha]->ddG(i, j, q);
                    }
                }
            }

            return ddG;
        }


        T constraintError(const boost::numeric::ublas::vector<T>& q) const {
            const boost::numeric::ublas::vector<T>& cstrts = constraints(q);
            return norm_2(cstrts);
        }



        virtual T V(const boost::numeric::ublas::vector<T>& q, const boost::numeric::ublas::vector<T>& v) const = 0;
        virtual boost::numeric::ublas::vector<T> dV(const boost::numeric::ublas::vector<T>& q, const boost::numeric::ublas::vector<T>& v) const = 0;


        virtual T kineticEnergy(const boost::numeric::ublas::vector<T>& v) const {
            T kin = 0;

            for (unsigned int i = 0; i < _mass.size(); ++i) {
                kin += _mass(i)*pow(v(i),2);
            }

            kin /= 2;

            return kin;
        }


        const boost::numeric::ublas::vector<T>& getMass() const { return _mass; }

        const std::vector<std::vector<unsigned int> >& getConstraintList() const { return this->_clist; }

        const std::vector<Constraint<T>* >& getConstraints() const { return this->_constraints; }


        void setInitialPosition(const boost::numeric::ublas::vector<T>& q) { _q0 = q; }
        void setInitialVelocity(const boost::numeric::ublas::vector<T>& v) { _v0 = v; }


    protected:
        void setNoCoordinates(unsigned int n) const { _N = n; }
        void setNoConstraints(unsigned int n) const { _M = n; }
        void setMass(const boost::numeric::ublas::vector<T>& mass) { _mass = mass; }
# 169 "/home/preben/working/CRTPlanner/MechSystem.hpp"
        unsigned int _N;
        unsigned int _M;


        boost::numeric::ublas::vector<T> _mass;


        boost::numeric::ublas::vector<T> _q0;
        boost::numeric::ublas::vector<T> _v0;

        std::vector<Constraint<T>* > _constraints;
        std::vector<std::vector<unsigned int> > _clist;
    };


} }
# 14 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 2
# 22 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
#define RW_KINEMATICS_FRAME_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
#define RW_MATH_TRANSFORM3D_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
#define RW_MATH_VECTOR3D_HPP 







# 1 "/usr/include/boost-1_41/boost/numeric/ublas/io.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/io.hpp"
#define _BOOST_UBLAS_IO_ 







namespace boost { namespace numeric { namespace ublas {

    template<class E, class T, class VE>

    std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
                                           const vector_expression<VE> &v) {
        typedef typename VE::size_type size_type;
        size_type size = v ().size ();
        std::basic_ostringstream<E, T, std::allocator<E> > s;
        s.flags (os.flags ());
        s.imbue (os.getloc ());
        s.precision (os.precision ());
        s << '[' << size << "](";
        if (size > 0)
            s << v () (0);
        for (size_type i = 1; i < size; ++ i)
            s << ',' << v () (i);
        s << ')';
        return os << s.str ().c_str ();
    }

    template<class E, class T, class VT, class VA>

    std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
                                           vector<VT, VA> &v) {
        typedef typename vector<VT, VA>::size_type size_type;
        E ch;
        size_type size;
        if (is >> ch && ch != '[') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (is >> size >> ch && ch != ']') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (! is.fail ()) {
            vector<VT, VA> s (size);
            if (is >> ch && ch != '(') {
                is.putback (ch);
                is.setstate (std::ios_base::failbit);
            } else if (! is.fail ()) {
                for (size_type i = 0; i < size; i ++) {
                    if (is >> s (i) >> ch && ch != ',') {
                        is.putback (ch);
                        if (i < size - 1)
                            is.setstate (std::ios_base::failbit);
                        break;
                    }
                }
                if (is >> ch && ch != ')') {
                    is.putback (ch);
                    is.setstate (std::ios_base::failbit);
                }
            }
            if (! is.fail ())
                v.swap (s);
        }
        return is;
    }

    template<class E, class T, class ME>

    std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
                                           const matrix_expression<ME> &m) {
        typedef typename ME::size_type size_type;
        size_type size1 = m ().size1 ();
        size_type size2 = m ().size2 ();
        std::basic_ostringstream<E, T, std::allocator<E> > s;
        s.flags (os.flags ());
        s.imbue (os.getloc ());
        s.precision (os.precision ());
        s << '[' << size1 << ',' << size2 << "](";
        if (size1 > 0) {
            s << '(' ;
            if (size2 > 0)
                s << m () (0, 0);
            for (size_type j = 1; j < size2; ++ j)
                s << ',' << m () (0, j);
            s << ')';
        }
        for (size_type i = 1; i < size1; ++ i) {
            s << ",(" ;
            if (size2 > 0)
                s << m () (i, 0);
            for (size_type j = 1; j < size2; ++ j)
                s << ',' << m () (i, j);
            s << ')';
        }
        s << ')';
        return os << s.str ().c_str ();
    }

    template<class E, class T, class MT, class MF, class MA>

    std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
                                           matrix<MT, MF, MA> &m) {
        typedef typename matrix<MT, MF, MA>::size_type size_type;
        E ch;
        size_type size1, size2;
        if (is >> ch && ch != '[') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (is >> size1 >> ch && ch != ',') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (is >> size2 >> ch && ch != ']') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (! is.fail ()) {
            matrix<MT, MF, MA> s (size1, size2);
            if (is >> ch && ch != '(') {
                is.putback (ch);
                is.setstate (std::ios_base::failbit);
            } else if (! is.fail ()) {
                for (size_type i = 0; i < size1; i ++) {
                    if (is >> ch && ch != '(') {
                        is.putback (ch);
                        is.setstate (std::ios_base::failbit);
                        break;
                    }
                    for (size_type j = 0; j < size2; j ++) {
                        if (is >> s (i, j) >> ch && ch != ',') {
                            is.putback (ch);
                            if (j < size2 - 1) {
                                is.setstate (std::ios_base::failbit);
                                break;
                            }
                        }
                    }
                    if (is >> ch && ch != ')') {
                        is.putback (ch);
                        is.setstate (std::ios_base::failbit);
                        break;
                    }
                    if (is >> ch && ch != ',') {
                       is.putback (ch);
                       if (i < size1 - 1) {
                            is.setstate (std::ios_base::failbit);
                            break;
                       }
                    }
                }
                if (is >> ch && ch != ')') {
                    is.putback (ch);
                    is.setstate (std::ios_base::failbit);
                }
            }
            if (! is.fail ())
                m.swap (s);
        }
        return is;
    }


    template<class E, class T, class MT, class MF1, class MF2, class MA>

    std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
                                           symmetric_matrix<MT, MF1, MF2, MA> &m) {
        typedef typename symmetric_matrix<MT, MF1, MF2, MA>::size_type size_type;
        E ch;
        size_type size1, size2;
        MT value;
        if (is >> ch && ch != '[') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (is >> size1 >> ch && ch != ',') {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (is >> size2 >> ch && (size2 != size1 || ch != ']')) {
            is.putback (ch);
            is.setstate (std::ios_base::failbit);
        } else if (! is.fail ()) {
            symmetric_matrix<MT, MF1, MF2, MA> s (size1, size2);
            if (is >> ch && ch != '(') {
                is.putback (ch);
                is.setstate (std::ios_base::failbit);
             } else if (! is.fail ()) {
                for (size_type i = 0; i < size1; i ++) {
                    if (is >> ch && ch != '(') {
                        is.putback (ch);
                        is.setstate (std::ios_base::failbit);
                        break;
                    }
                    for (size_type j = 0; j < size2; j ++) {
                        if (is >> value >> ch && ch != ',') {
                            is.putback (ch);
                            if (j < size2 - 1) {
                                is.setstate (std::ios_base::failbit);
                                break;
                            }
                        }
                        if (i <= j) {

                            s(i,j) = value;
                        }
                        else if ( s(i,j) != value ) {

                            is.setstate (std::ios_base::failbit);
                            break;
                        }
                     }
                     if (is >> ch && ch != ')') {
                         is.putback (ch);
                         is.setstate (std::ios_base::failbit);
                         break;
                     }
                     if (is >> ch && ch != ',') {
                        is.putback (ch);
                        if (i < size1 - 1) {
                             is.setstate (std::ios_base::failbit);
                             break;
                        }
                     }
                }
                if (is >> ch && ch != ')') {
                    is.putback (ch);
                    is.setstate (std::ios_base::failbit);
                }
            }
            if (! is.fail ())
                m.swap (s);
        }
        return is;
    }


}}}
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp" 2

namespace rw { namespace math {
# 57 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template<class T = double>
    class Vector3D
    {
    public:

        typedef boost::numeric::ublas::bounded_vector<T, 3> Base;


        typedef T value_type;




        Vector3D()
        {
            m()(0) = 0;
            m()(1) = 0;
            m()(2) = 0;
        }







        Vector3D(T x, T y, T z)
        {
            m()(0) = x;
            m()(1) = y;
            m()(2) = z;
        }






        template <class R>
        explicit Vector3D(const boost::numeric::ublas::vector_expression<R>& r) :
            _vec(r)
        {}




        const Base& m() const { return _vec; }




        Base& m() { return _vec; }







        size_t size() const { return 3; }
# 126 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
        const T& operator()(size_t i) const { return m()(i); }






        T& operator()(size_t i) { return m()(i); }






        const T& operator[](size_t i) const { return m()(i); }






        T& operator[](size_t i) { return m()(i); }
# 160 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
        friend const Vector3D<T> operator/(const Vector3D<T>& v, T s)
        {
            return Vector3D<T>(v.m() / s);
        }




        friend const Vector3D<T> operator*(const Vector3D<T>& v, T s)
        {
            return Vector3D<T>(v.m() * s);
        }




        friend const Vector3D<T> operator*(T s, const Vector3D<T>& v)
        {
            return Vector3D<T>(s * v.m());
        }




        friend const Vector3D<T> operator-(const Vector3D<T>& a, const Vector3D<T>& b)
        {
            return Vector3D<T>(a[0] - b[0], a[1] - b[1], a[2] - b[2]);

        }




        friend const Vector3D<T> operator+(const Vector3D<T>& a, const Vector3D<T>& b)
        {
            return Vector3D<T>(a[0] + b[0], a[1] + b[1], a[2] + b[2]);

        }




        Vector3D<T>& operator*=(T s)
        {
            m() *= s;
            return *this;
        }




        Vector3D<T>& operator/=(T s)
        {
            m() /= s;
            return *this;
        }




        Vector3D<T>& operator+=(const Vector3D<T>& v)
        {
            m()(0) += v.m()(0);
            m()(1) += v.m()(1);
            m()(2) += v.m()(2);

            return *this;
        }




        Vector3D<T>& operator-=(const Vector3D<T>& v)
        {
            m() -= v.m();
            return *this;
        }




        const Vector3D<T> operator-() const
        {
            return Vector3D<T>(-m());
        }




        friend std::ostream& operator<<(std::ostream& out, const Vector3D<T>& v)
        {
            return out
                << "Vector3D {"
                << v[0] << ", " << v[1] << ", " << v[2]
                << "}";
        }
# 264 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
        T norm2() const {
            return norm_2(m());
        }





        T norm1() const {
            return norm_1(m());
        }





        T normInf() const {
            return norm_inf(m());
        }
    private:
        Base _vec;
    };
# 296 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    bool operator==(const Vector3D<T>& a, const Vector3D<T>& b)
    { return a[0] == b[0] && a[1] == b[1] && a[2] == b[2]; }
# 318 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    const Vector3D<T> cross(const Vector3D<T>& v1, const Vector3D<T>& v2)
    {
        return Vector3D<T>(
            v1[1] * v2[2] - v1[2] * v2[1],
            v1[2] * v2[0] - v1[0] * v2[2],
            v1[0] * v2[1] - v1[1] * v2[0]);
    }
# 336 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    T dot(const Vector3D<T>& v1, const Vector3D<T>& v2)
    {
        return inner_prod(v1.m(), v2.m());
    }
# 350 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    const Vector3D<T> normalize(const Vector3D<T>& v)
    {
        T length = norm_2(v.m());
        if (length != 0)
            return Vector3D<T>(v(0)/length, v(1)/length, v(2)/length);
        else
            return Vector3D<T>(0,0,0);
    }
# 372 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    double angle(const Vector3D<T>& v1, const Vector3D<T>& v2, const Vector3D<T>& n)
    {
        const Vector3D<T> nv1 = normalize(v1);
        const Vector3D<T> nv2 = normalize(v2);
        const Vector3D<T> nn = normalize(n);
        return atan2(dot(nn, cross(nv1, nv2)), dot(nv1, nv2));
    }
# 391 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template <class T>
    double angle(const Vector3D<T>& v1, const Vector3D<T>& v2)
    {
        Vector3D<> n = cross(v1, v2);
        return angle(v1,v2,n);
    }
# 405 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp"
    template<class Q, class T>
    const Vector3D<Q> cast(const Vector3D<T>& v)
    {
        return Vector3D<Q>(
            static_cast<Q>(v(0)),
            static_cast<Q>(v(1)),
            static_cast<Q>(v(2)));
    }



}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
#define RW_MATH_ROTATION3D_HPP 







# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define rw_common_macros_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Exception.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Exception.hpp"
#define RW_COMMON_EXCEPTION_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp"
#define RW_COMMON_MESSAGE_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp"
namespace rw { namespace common {
# 48 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp"
    class Message
    {
    public:
# 67 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp"
        Message(const std::string& file,
                int line,
                const std::string& message):
            _file(file),
            _line(line),
            _message(message)
        {}







        const std::string& getFile() const { return _file; }







        int getLine() const { return _line; }






        const std::string& getText() const { return _message; }




        std::string getFullText() const {
            std::stringstream sstr;
            sstr<<_file<<":"<<_line<<" : "<<_message;
            return sstr.str();
        }

    private:
        std::string _file;
        int _line;
        std::string _message;
    };
# 121 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp"
    std::ostream& operator<<(std::ostream& out, const Message& msg);


}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Exception.hpp" 2




namespace rw { namespace common {
# 44 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Exception.hpp"
    class Exception
    {
    public:





        Exception(const Message& message) :
            _id(-1),
            _message(message)
        {}







        Exception(int id, const Message& message) :
            _id(id),
            _message(message)
        {}







        const Message& getMessage() const { return _message; }

        int getId() const {
            return _id;
        }

        std::string what() const {
            std::stringstream sstr;
            sstr<<"Id["<<_id<<"]"<<_message.getFullText();
            return sstr.str();
        }

    private:
        int _id;
        Message _message;
    };
# 101 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Exception.hpp"
    std::ostream& operator<<(std::ostream& out, const Exception& exp);


}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
#define RW_COMMON_LOG_HPP 
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/LogWriter.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/LogWriter.hpp"
#define RW_COMMON_LOGWRITER_HPP 




# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp"
#define RW_COMMON_PTR_HPP 






# 1 "/usr/include/boost-1_41/boost/shared_ptr.hpp" 1

#define BOOST_SHARED_PTR_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/shared_ptr.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 1

#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
# 1 "/usr/include/boost-1_41/boost/config/no_tr1/memory.hpp" 1
# 14 "/usr/include/boost-1_41/boost/config/no_tr1/memory.hpp"
#define BOOST_CONFIG_MEMORY 


#define BOOST_TR1_NO_RECURSION 
#define BOOST_CONFIG_NO_MEMORY_RECURSION 





#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_MEMORY_RECURSION
# 28 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/usr/include/boost-1_41/boost/assert.hpp" 1
# 16 "/usr/include/boost-1_41/boost/assert.hpp"
#undef BOOST_ASSERT
# 36 "/usr/include/boost-1_41/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 37 "/usr/include/boost-1_41/boost/assert.hpp" 2
#define BOOST_ASSERT(expr) assert(expr)


#undef BOOST_VERIFY







#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# 30 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2
# 1 "/usr/include/boost-1_41/boost/checked_delete.hpp" 1

#define BOOST_CHECKED_DELETE_HPP_INCLUDED 
# 24 "/usr/include/boost-1_41/boost/checked_delete.hpp"
namespace boost
{



template<class T> inline void checked_delete(T * x)
{

    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};

}
# 31 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED 
# 28 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/bad_weak_ptr.hpp" 1

#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/smart_ptr/bad_weak_ptr.hpp"
namespace boost
{
# 39 "/usr/include/boost-1_41/boost/smart_ptr/bad_weak_ptr.hpp"
class bad_weak_ptr: public std::exception
{
public:

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





}
# 29 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp" 2
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_has_sync.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_has_sync.hpp"
#define BOOST_SP_HAS_SYNC 
# 22 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base.hpp" 2
# 36 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp"
# 1 "/usr/include/boost-1_41/boost/detail/sp_typeinfo.hpp" 1

#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED 
# 57 "/usr/include/boost-1_41/boost/detail/sp_typeinfo.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/typeinfo" 1 3
# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/typeinfo" 3
#define _TYPEINFO 



#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/typeinfo" 3
#define __GXX_MERGED_TYPEINFO_NAMES 1
# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/typeinfo" 3
#define __GXX_TYPEINFO_EQUALITY_INLINE 1



namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const
    { return __name; }
# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }


    virtual bool __is_pointer_p() const;


    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
       unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
        void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);
  };







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



    virtual ~bad_cast() throw();


    virtual const char* what() const throw();
  };





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



    virtual ~bad_typeid() throw();


    virtual const char* what() const throw();
  };
}

#pragma GCC visibility pop

}
# 58 "/usr/include/boost-1_41/boost/detail/sp_typeinfo.hpp" 2

namespace boost
{

namespace detail
{







typedef std::type_info sp_typeinfo;



}

}

#define BOOST_SP_TYPEID(T) typeid(T)
# 28 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 2

namespace boost
{

namespace detail
{

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




    int r;

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

    return r;
}

inline void atomic_increment( int * pw )
{


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

inline int atomic_conditional_increment( int * pw )
{




    int rv, tmp;

    __asm__
    (
        "movl %0, %%eax\n\t"
        "0:\n\t"
        "test %%eax, %%eax\n\t"
        "je 1f\n\t"
        "movl %%eax, %2\n\t"
        "incl %2\n\t"
        "lock\n\t"
        "cmpxchgl %2, %0\n\t"
        "jne 0b\n\t"
        "1:":
        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
        "m"( *pw ):
        "cc"
    );

    return rv;
}

class sp_counted_base
{
private:

    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );

    int use_count_;
    int weak_count_;

public:

    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }

    virtual ~sp_counted_base()
    {
    }




    virtual void dispose() = 0;



    virtual void destroy()
    {
        delete this;
    }

    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;

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

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

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

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

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

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

}

}
# 37 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_base.hpp" 2
# 30 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp" 2
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED 
# 38 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 39 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp" 2

namespace boost
{
# 50 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp"
namespace detail
{

template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;

    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );

    typedef sp_counted_impl_p<X> this_type;

public:

    explicit sp_counted_impl_p( X * px ): px_( px )
    {



    }

    virtual void dispose()
    {



        boost::checked_delete( px_ );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & )
    {
        return 0;
    }
# 113 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp"
};
# 122 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp"
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:

    P ptr;
    D del;

    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );

    typedef sp_counted_impl_pd<P, D> this_type;

public:



    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
    {
    }

    virtual void dispose()
    {
        del( ptr );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
    }
# 179 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_counted_impl.hpp"
};

template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:

    P p_;
    D d_;
    A a_;

    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );

    typedef sp_counted_impl_pda<P, D, A> this_type;

public:



    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
    {
    }

    virtual void dispose()
    {
        d_( p_ );
    }

    virtual void destroy()
    {
        typedef typename A::template rebind< this_type >::other A2;

        A2 a2( a_ );

        this->~this_type();
        a2.deallocate( this, 1 );
    }

    virtual void * get_deleter( detail::sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
    }
};





}

}
# 31 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp" 2
# 40 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
namespace boost
{

namespace detail
{
# 53 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
struct sp_nothrow_tag {};

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;





    friend class weak_count;

public:

    shared_count(): pi_(0)



    {
    }

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )



    {


        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
# 106 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
    }




    template<class P, class D> shared_count( P p, D d ): pi_(0)




    {





        try
        {
            pi_ = new sp_counted_impl_pd<P, D>(p, d);
        }
        catch(...)
        {
            d(p);
            throw;
        }
# 143 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
    }

    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )



    {
        typedef sp_counted_impl_pda<P, D, A> impl_type;
        typedef typename A::template rebind< impl_type >::other A2;

        A2 a2( a );



        try
        {
            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
        }
        catch(...)
        {
            d( p );

            if( pi_ != 0 )
            {
                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
            }

            throw;
        }
# 189 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
    }





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



    {
# 210 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
        r.release();
    }



    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();



    }

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



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }
# 243 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag );

    shared_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(shared_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const
    {
        return use_count() == 1;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
    }

    void * get_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;





    friend class shared_count;

public:

    weak_count(): pi_(0)



    {
    }

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



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

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



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
# 350 "/usr/include/boost-1_41/boost/smart_ptr/detail/shared_count.hpp"
    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();



    }

    weak_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    weak_count & operator= (weak_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(weak_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
};

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



{
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )



{
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
}

}

}
# 33 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_convertible.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED 
# 34 "/usr/include/boost-1_41/boost/smart_ptr/detail/sp_convertible.hpp"
namespace boost
{

namespace detail
{

template< class Y, class T > struct sp_convertible
{
    typedef char (&yes) [1];
    typedef char (&no) [2];

    static yes f( T* );
    static no f( ... );

    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
};

struct sp_empty
{
};

template< bool > struct sp_enable_if_convertible_impl;

template<> struct sp_enable_if_convertible_impl<true>
{
    typedef sp_empty type;
};

template<> struct sp_enable_if_convertible_impl<false>
{
};

template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};

}

}
# 35 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2


# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_pool.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_pool.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED 
# 38 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_sync.hpp" 1

#define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_sync.hpp"
# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/yield_k.hpp" 1

#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED 
# 39 "/usr/include/boost-1_41/boost/smart_ptr/detail/yield_k.hpp"
#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
# 91 "/usr/include/boost-1_41/boost/smart_ptr/detail/yield_k.hpp"
namespace boost
{

namespace detail
{

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

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

    else if( k < 32 || k & 1 )
    {
        sched_yield();
    }
    else
    {

        struct timespec rqtp = { 0, 0 };




        rqtp.tv_sec = 0;
        rqtp.tv_nsec = 1000;

        nanosleep( &rqtp, 0 );
    }
}

}

}
# 19 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_sync.hpp" 2





namespace boost
{

namespace detail
{

class spinlock
{
public:

    int v_;

public:

    bool try_lock()
    {
        int r = __sync_lock_test_and_set( &v_, 1 );
        return r == 0;
    }

    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }

    void unlock()
    {
        __sync_lock_release( &v_ );
    }

public:

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

}
}

#define BOOST_DETAIL_SPINLOCK_INIT {0}
# 39 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock.hpp" 2
# 26 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_pool.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 27 "/usr/include/boost-1_41/boost/smart_ptr/detail/spinlock_pool.hpp" 2

namespace boost
{

namespace detail
{

template< int I > class spinlock_pool
{
private:

    static spinlock pool_[ 41 ];

public:

    static spinlock & spinlock_for( void const * pv )
    {
        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
        return pool_[ i ];
    }

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
        {
            sp_.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
{
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}, {0}, {0}, {0}, {0},
    {0}
};

}
}
# 38 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2
# 1 "/usr/include/boost-1_41/boost/memory_order.hpp" 1

#define BOOST_MEMORY_ORDER_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/memory_order.hpp"
namespace boost
{

enum memory_order
{
    memory_order_relaxed = 0,
    memory_order_acquire = 1,
    memory_order_release = 2,
    memory_order_acq_rel = 3,
    memory_order_seq_cst = 7
};

}
# 39 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2
# 58 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
namespace boost
{

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

namespace detail
{

struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct polymorphic_cast_tag {};

template<class T> struct shared_ptr_traits
{
    typedef T & reference;
};

template<> struct shared_ptr_traits<void>
{
    typedef void reference;
};



template<> struct shared_ptr_traits<void const>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void volatile>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void const volatile>
{
    typedef void reference;
};





template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}
# 136 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
inline void sp_enable_shared_from_this( ... )
{
}







template< class T, class R > struct sp_enable_if_auto_ptr
{
};

template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
    typedef R type;
};



}
# 168 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;

    shared_ptr(): px(0), pn()
    {
    }

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }







    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }



    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }



    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
    {

        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )






    : px( r.px ), pn( r.pn )
    {
    }


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

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

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

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            pn = boost::detail::shared_count();
        }
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }



    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = boost::detail::shared_count(r);
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }



    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typename Ap::element_type * tmp = r.get();
        pn = boost::detail::shared_count( r );
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }
# 303 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
    shared_ptr & operator=( shared_ptr const & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r)
    {
        this_type(r).swap(*this);
        return *this;
    }





    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
    {
        this_type( r ).swap( *this );
        return *this;
    }
# 384 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
    void reset()
    {
        this_type().swap(*this);
    }

    template<class Y> void reset(Y * p)
    {
        ((p == 0 || p != px) ? static_cast<void> (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp", 391, __PRETTY_FUNCTION__));
        this_type(p).swap(*this);
    }

    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, d ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, d, a ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
    {
        this_type( r, p ).swap( *this );
    }

    reference operator* () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp", 412, __PRETTY_FUNCTION__));
        return *px;
    }

    T * operator-> () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp", 418, __PRETTY_FUNCTION__));
        return px;
    }

    T * get() const
    {
        return px;
    }


# 1 "/usr/include/boost-1_41/boost/smart_ptr/detail/operator_bool.hpp" 1
# 43 "/usr/include/boost-1_41/boost/smart_ptr/detail/operator_bool.hpp"
    typedef T * this_type::*unspecified_bool_type;

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




    bool operator! () const
    {
        return px == 0;
    }
# 429 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp" 2

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

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

    void swap(shared_ptr<T> & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }

    void * _internal_get_deleter( detail::sp_typeinfo const & ti ) const
    {
        return pn.get_deleter( ti );
    }

    bool _internal_equiv( shared_ptr const & r ) const
    {
        return px == r.px && pn == r.pn;
    }






private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;




    T * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() != b.get();
}
# 500 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a._internal_less(b);
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::const_cast_tag());
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}



template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
{
    ((dynamic_cast<T *>(r.get()) == r.get()) ? static_cast<void> (0) : __assert_fail ("dynamic_cast<T *>(r.get()) == r.get()", "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp", 544, __PRETTY_FUNCTION__));
    return shared_static_cast<T>(r);
}



template<class T> inline T * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}
# 577 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)

{
    os << p.get();
    return os;
}
# 607 "/usr/include/boost-1_41/boost/smart_ptr/shared_ptr.hpp"
template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
}







template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * )
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
    return atomic_compare_exchange( p, v, w );
}



}
# 18 "/usr/include/boost-1_41/boost/shared_ptr.hpp" 2
# 28 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp" 2

namespace rw { namespace common {







    template <class T>
    class Ptr
    {
    public:

        typedef boost::shared_ptr<T> shared_ptr;


        typedef T* pointer;


        typedef T& reference;


        typedef T value_type;




        Ptr() :
            _ptr(0),
            _owned_ptr()
        {}
# 68 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp"
        Ptr(T* ptr) :
            _ptr(ptr),
            _owned_ptr()
        {}
# 82 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp"
        Ptr(shared_ptr ptr) :
            _ptr(ptr.get()),
            _owned_ptr(ptr)
        {}
# 94 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp"
        Ptr(std::auto_ptr<T> ptr) :
            _ptr(ptr.get()),
            _owned_ptr(ptr.release())
        {}


        template <class S>
        Ptr<S> cast() {
            if (_owned_ptr)
                return Ptr<S>(boost::dynamic_pointer_cast<S>(_owned_ptr));
            else
                return Ptr<S>(dynamic_cast<S*>(_ptr));
        }




        template <class S>
        operator Ptr<S> ()
        {
            if (_owned_ptr)
                return Ptr<S>(_owned_ptr);
            else
                return Ptr<S>(_ptr);
        }





        pointer get() const { return _ptr; }




        reference operator*() const { return *get(); }




        pointer operator->() const { return get(); }




        operator void* () const { return get(); }






        bool isShared(){
            if (_owned_ptr)
                return true;
            else
                return false;
        }

    private:
        T* _ptr;
        boost::shared_ptr<T> _owned_ptr;
    };






    template <class T>
    Ptr<T> ownedPtr(T* ptr) { return Ptr<T>(std::auto_ptr<T>(ptr)); }


}}
# 26 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/LogWriter.hpp" 2

namespace rw { namespace common {
# 37 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/LogWriter.hpp"
    class LogWriter
    {
    public:




        virtual ~LogWriter();




        virtual void flush() = 0;





        virtual void write(const std::string& str) = 0;
# 65 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/LogWriter.hpp"
        virtual void write(const Message& msg);







        virtual void writeln(const std::string& str);




        template< class T>
        LogWriter& operator<<( T t ){
            std::stringstream tmp;
            tmp << t;
            return this->operator<<( tmp.str() );
        }




        LogWriter& operator<<(const std::string& str){
         write(str);
         return *this;
        }




        LogWriter& operator<<(const char* str){
         write(str);
         return *this;
        }




        LogWriter& operator<<(std::ostream& (*pf)(std::ostream&));

    protected:
        LogWriter() {}

    private:
        LogWriter(const LogWriter&);
        LogWriter& operator=(const LogWriter&);
    };



    typedef rw::common::Ptr<rw::common::LogWriter> LogWriterPtr;

}}
# 33 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Message.hpp" 1
# 34 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Ptr.hpp" 1
# 35 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp" 2

namespace rw { namespace common {
    class Log;
    typedef rw::common::Ptr<Log> LogPtr;
# 74 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
    class Log
    {
    public:

     enum LogLevelMask {
      FatalMask=1, CriticalMask=2,
      ErrorMask=4, WarningMask=8,
      InfoMask=16, DebugMask=32,
      User1Mask=64, User2Mask=128,
      User3Mask=256, User4Mask=512,
      User5Mask=1024, User6Mask=2048,
      User7Mask=4096, User8Mask=8096
     };

     enum LogLevel {
      Fatal=0, Critical=1,
      Error=2, Warning=3,
      Info=4, Debug=5,
      User1=6, User2=7,
      User3=8, User4=9,
      User5=10, User6=11,
      User7=12, User8=13
     };






        static LogWriter& infoLog(){ return Log::log().get(Info);};






        static LogWriter& warningLog(){ return Log::log().get(Warning);};






        static LogWriter& errorLog(){ return Log::log().get(Error);};






        static LogWriter& debugLog(){ return Log::log().get(Debug);};






        static LogPtr getInstance();





        static Log& log();





        static void setLog(LogPtr log);





        Log();




        virtual ~Log();
# 171 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void setWriter(LogLevel id, LogWriterPtr writer);
# 181 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        LogWriter& get(LogLevel id);
# 191 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void write(LogLevel id, const std::string& message);
# 202 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void write(LogLevel id, const Message& message);
# 212 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void writeln(LogLevel id, const std::string& message);
# 221 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void flush(LogLevel id);




        void flushAll();
# 235 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Log.hpp"
        void remove(LogLevel id);






        rw::common::LogWriter& info(){ return get(Info);};






        rw::common::LogWriter& warning(){ return get(Warning);};






        rw::common::LogWriter& error(){ return get(Error);};






        rw::common::LogWriter& debug(){ return get(Debug);};






        void setLogLevelMask( int loglvl ){ _logLevelMask=loglvl; };





        int getLogLevelMask() const{ return _logLevelMask; };

    private:
     bool isValidLogLevel(LogLevel id);

  int _logLevelMask;
  std::vector<rw::common::LogWriterPtr> _writers;
  rw::common::LogWriterPtr _defaultWriter;
    };



}}
# 28 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
#define RW_COMMON_IOUTIL_HPP 
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
namespace rw { namespace common {







    class IOUtil
    {
    public:
# 58 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
        static void readFile(const std::string& file_name, std::vector<char>& result);
# 81 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
        static std::string resolveFileName(const std::string& filename,
                                           const std::vector<std::string>& extensions);
# 98 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
        static void rwAssert(const char* expression, const char* file, int line);
# 107 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
        static std::string getAbsoluteFileName(const std::string& file);





        static bool isLittleEndian();
# 125 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/IOUtil.hpp"
        static std::vector<std::string> getFilesInFolder(const std::string& path, bool recursive, bool addPath = true, const std::string& mask = "*");

        static void getFilesInFolder(const std::string& path, const std::string& fileMask, bool recursive, bool addPath, std::vector<std::string>& result);
    };


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp" 2
# 47 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_THROW(ostreamExpression) do { int RW__line = __LINE__; std::stringstream RW__stream; RW__stream << ostreamExpression; rw::common::Message RW__message(__FILE__, RW__line, RW__stream.str()); rw::common::Log::errorLog().write(RW__message); throw rw::common::Exception(RW__message); } while (0)
# 69 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_THROW2(id,ostreamExpression) do { int RW__line = __LINE__; std::stringstream RW__stream; RW__stream << ostreamExpression; rw::common::Message RW__message(__FILE__, RW__line, RW__stream.str()); rw::common::Exception exp(id, RW__message); rw::common::Log::errorLog().write(exp.what()); throw exp; } while (0)
# 90 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_WARN(ostreamExpression) do { int RW__line = __LINE__; std::stringstream RW__stream; RW__stream << ostreamExpression; rw::common::Message RW__message(__FILE__, RW__line, RW__stream.str()); rw::common::Log::warningLog().write(RW__message); } while (0)
# 116 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_DEBUG(ostreamExpression) 





#define RW_ASSERT_IMPL(e,file,line) ((e) ? (void)0 : rw::common::IOUtil::rwAssert(#e, file, line))
# 137 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_ASSERT(e) RW_ASSERT_IMPL(e, __FILE__, __LINE__)
# 160 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_LOG_TEXT(id,ostreamExpression) do { std::stringstream RW__stream; RW__stream << ostreamExpression; rw::common::Log::log().write(id, RW__stream.str()); } while (0)
# 182 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_LOG(id,ostreamExpression) do { std::stringstream RW__stream; RW__stream << ostreamExpression << "\n"; rw::common::Log::log().get(id).write(Messages(RW__stream.str(), __LINE__, __FILE__); } while (0)
# 205 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp"
#define RW_WRITE_LOG(log,ostreamExpression) do { std::stringstream RW__stream; RW__stream << ostreamExpression << "\n"; log.write(RW__stream.str()); } while (0)






#define USE_ROBWORK_NAMESPACE namespace rw { namespace proximity {}} namespace rw { namespace common {}} namespace rw { namespace control {}} namespace rw { namespace geometry {}} namespace rw { namespace interpolator {}} namespace rw { namespace trajectory {}} namespace rw { namespace invkin {}} namespace rw { namespace kinematics {}} namespace rw { namespace math {}} namespace rw { namespace task {}} namespace rw { namespace models {}} namespace rw { namespace pathplanning {}} namespace rw { namespace sensor {}} namespace rw { namespace loaders {}} namespace robwork { using namespace rw; using namespace rw::proximity; using namespace rw::common; using namespace rw::control; using namespace rw::geometry; using namespace rw::interpolator; using namespace rw::trajectory; using namespace rw::invkin; using namespace rw::kinematics; using namespace rw::math; using namespace rw::task; using namespace rw::models; using namespace rw::pathplanning; using namespace rw::sensor; using namespace rw::loaders; }
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp" 2



# 1 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
#define _BOOST_UBLAS_MATRIX_PROXY_ 




# 1 "/usr/include/boost-1_41/boost/numeric/ublas/detail/temporary.hpp" 1
# 14 "/usr/include/boost-1_41/boost/numeric/ublas/detail/temporary.hpp"
#define _BOOST_UBLAS_TEMPORARY_ 


namespace boost { namespace numeric { namespace ublas {


template <class M>
struct vector_temporary_traits {
   typedef typename M::vector_temporary_type type ;
};


template <class M>
struct matrix_temporary_traits {
   typedef typename M::matrix_temporary_type type ;
};

} } }
# 20 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" 2



namespace boost { namespace numeric { namespace ublas {


    template<class M>
    class matrix_row:
        public vector_expression<matrix_row<M> > {

        typedef matrix_row<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;


       
        matrix_row (matrix_type &data, size_type i):
            data_ (data), i_ (i) {


        }


       
        size_type size () const {
            return data_.size2 ();
        }
       
        size_type index () const {
            return i_;
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type j) const {
            return data_ (i_, j);
        }
       
        reference operator () (size_type j) {
            return data_ (i_, j);
        }

       
        const_reference operator [] (size_type j) const {
            return (*this) (j);
        }
       
        reference operator [] (size_type j) {
            return (*this) (j);
        }
# 111 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_row &operator = (const matrix_row &mr) {

            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (mr));
            return *this;
        }
       
        matrix_row &assign_temporary (matrix_row &mr) {

            vector_assign<scalar_assign> (*this, mr);
            return *this;
        }
        template<class AE>
       
        matrix_row &operator = (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_row &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_row &operator += (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_row &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_row &operator -= (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_row &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_row &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_row &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_row &mr) const {
            return (*this).data_.same_closure (mr.data_);
        }


       
        bool operator == (const matrix_row &mr) const {
            return (*this).data_ == mr.data_ && index () == mr.index ();
        }


       
        void swap (matrix_row mr) {
            if (this != &mr) {
                if (! (size () == mr.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 188 << ":" << std::endl; std::cerr << "size () == mr.size ()" << std::endl; bad_size ().raise (); };


                vector_swap<scalar_swap> (*this, mr);
            }
        }
       
        friend void swap (matrix_row mr1, matrix_row mr2) {
            mr1.swap (mr2);
        }


    private:
        typedef typename M::const_iterator2 const_subiterator_type;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_iterator2,
                                          typename M::iterator2>::type subiterator_type;

    public:






        class const_iterator;
        class iterator;



       
        const_iterator find (size_type j) const {
            const_subiterator_type it2 (data_.find2 (1, i_, j));



            return const_iterator (*this, it2);

        }
       
        iterator find (size_type j) {
            subiterator_type it2 (data_.find2 (1, i_, j));



            return iterator (*this, it2);

        }


        class const_iterator:
            public container_const_reference<matrix_row>,
            public iterator_base_traits<typename const_subiterator_type::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename const_subiterator_type::value_type value_type;
            typedef typename const_subiterator_type::difference_type difference_type;
            typedef typename const_subiterator_type::reference reference;
            typedef typename const_subiterator_type::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &mr, const const_subiterator_type &it):
                container_const_reference<self_type> (mr), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 282 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 289 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_.index2 ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 314 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 319 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        class iterator:
            public container_reference<matrix_row>,
            public iterator_base_traits<typename subiterator_type::iterator_category>::template
                        iterator_base<iterator, value_type>::type {
        public:
            typedef typename subiterator_type::value_type value_type;
            typedef typename subiterator_type::difference_type difference_type;
            typedef typename subiterator_type::reference reference;
            typedef typename subiterator_type::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &mr, const subiterator_type &it):
                container_reference<self_type> (mr), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 379 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 386 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_.index2 ();
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 411 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 416 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };


       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        matrix_closure_type data_;
        size_type i_;
    };


    template<class M>
   
    matrix_row<M> row (M &data, typename M::size_type i) {
        return matrix_row<M> (data, i);
    }
    template<class M>
   
    const matrix_row<const M> row (const M &data, typename M::size_type i) {
        return matrix_row<const M> (data, i);
    }


    template <class M>
    struct vector_temporary_traits< matrix_row<M> >
    : vector_temporary_traits< M > {} ;
    template <class M>
    struct vector_temporary_traits< const matrix_row<M> >
    : vector_temporary_traits< M > {} ;


    template<class M>
    class matrix_column:
        public vector_expression<matrix_column<M> > {

        typedef matrix_column<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;


       
        matrix_column (matrix_type &data, size_type j):
            data_ (data), j_ (j) {


        }


       
        size_type size () const {
            return data_.size1 ();
        }
       
        size_type index () const {
            return j_;
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i) const {
            return data_ (i, j_);
        }
       
        reference operator () (size_type i) {
            return data_ (i, j_);
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }
# 568 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_column &operator = (const matrix_column &mc) {

            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (mc));
            return *this;
        }
       
        matrix_column &assign_temporary (matrix_column &mc) {

            vector_assign<scalar_assign> (*this, mc);
            return *this;
        }
        template<class AE>
       
        matrix_column &operator = (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_column &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_column &operator += (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_column &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_column &operator -= (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_column &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_column &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_column &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_column &mc) const {
            return (*this).data_.same_closure (mc.data_);
        }


       
        bool operator == (const matrix_column &mc) const {
            return (*this).data_ == mc.data_ && index () == mc.index ();
        }


       
        void swap (matrix_column mc) {
            if (this != &mc) {
                if (! (size () == mc.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 645 << ":" << std::endl; std::cerr << "size () == mc.size ()" << std::endl; bad_size ().raise (); };


                vector_swap<scalar_swap> (*this, mc);
            }
        }
       
        friend void swap (matrix_column mc1, matrix_column mc2) {
            mc1.swap (mc2);
        }


    private:
        typedef typename M::const_iterator1 const_subiterator_type;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_iterator1,
                                          typename M::iterator1>::type subiterator_type;

    public:






        class const_iterator;
        class iterator;



       
        const_iterator find (size_type i) const {
            const_subiterator_type it1 (data_.find1 (1, i, j_));



            return const_iterator (*this, it1);

        }
       
        iterator find (size_type i) {
            subiterator_type it1 (data_.find1 (1, i, j_));



            return iterator (*this, it1);

        }


        class const_iterator:
            public container_const_reference<matrix_column>,
            public iterator_base_traits<typename const_subiterator_type::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:
            typedef typename const_subiterator_type::value_type value_type;
            typedef typename const_subiterator_type::difference_type difference_type;
            typedef typename const_subiterator_type::reference reference;
            typedef typename const_subiterator_type::pointer pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator (const self_type &mc, const const_subiterator_type &it):
                container_const_reference<self_type> (mc), it_ (it) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 739 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 746 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_.index1 ();
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 771 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 776 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator_type it_;
        };


       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }


        class iterator:
            public container_reference<matrix_column>,
            public iterator_base_traits<typename subiterator_type::iterator_category>::template
                        iterator_base<iterator, value_type>::type {
        public:
            typedef typename subiterator_type::value_type value_type;
            typedef typename subiterator_type::difference_type difference_type;
            typedef typename subiterator_type::reference reference;
            typedef typename subiterator_type::pointer pointer;


           
            iterator ():
                container_reference<self_type> (), it_ () {}
           
            iterator (self_type &mc, const subiterator_type &it):
                container_reference<self_type> (mc), it_ (it) {}


           
            iterator &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 836 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                if (! (index () < (*this) ().size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 843 << ":" << std::endl; std::cerr << "index () < (*this) ().size ()" << std::endl; bad_index ().raise (); };
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return it_.index1 ();
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 868 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 873 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator_type it_;

            friend class const_iterator;
        };


       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        matrix_closure_type data_;
        size_type j_;
    };


    template<class M>
   
    matrix_column<M> column (M &data, typename M::size_type j) {
        return matrix_column<M> (data, j);
    }
    template<class M>
   
    const matrix_column<const M> column (const M &data, typename M::size_type j) {
        return matrix_column<const M> (data, j);
    }


    template <class M>
    struct vector_temporary_traits< matrix_column<M> >
    : vector_temporary_traits< M > {} ;
    template <class M>
    struct vector_temporary_traits< const matrix_column<M> >
    : vector_temporary_traits< M > {} ;


    template<class M>
    class matrix_vector_range:
        public vector_expression<matrix_vector_range<M> > {

        typedef matrix_vector_range<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef basic_range<size_type, difference_type> range_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;


       
        matrix_vector_range (matrix_type &data, const range_type &r1, const range_type &r2):
            data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {






        }


       
        size_type start1 () const {
            return r1_.start ();
        }
       
        size_type start2 () const {
            return r2_.start ();
        }
       
        size_type size () const {
            return same_impl_ex ((r1_.size ()), (r2_.size ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 988);
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i) const {
            return data_ (r1_ (i), r2_ (i));
        }
       
        reference operator () (size_type i) {
            return data_ (r1_ (i), r2_ (i));
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }
# 1033 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_vector_range &operator = (const matrix_vector_range &mvr) {

            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (mvr));
            return *this;
        }
       
        matrix_vector_range &assign_temporary (matrix_vector_range &mvr) {

            vector_assign<scalar_assign> (*this, mvr);
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &operator = (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &operator += (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &operator -= (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_range &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_vector_range &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_vector_range &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_vector_range &mvr) const {
            return (*this).data_.same_closure (mvr.data_);
        }


       
        bool operator == (const matrix_vector_range &mvr) const {
            return (*this).data_ == mvr.data_ && r1_ == mvr.r1_ && r2_ == mvr.r2_;
        }


       
        void swap (matrix_vector_range mvr) {
            if (this != &mvr) {
                if (! (size () == mvr.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1110 << ":" << std::endl; std::cerr << "size () == mvr.size ()" << std::endl; bad_size ().raise (); };


                vector_swap<scalar_swap> (*this, mvr);
            }
        }
       
        friend void swap (matrix_vector_range mvr1, matrix_vector_range mvr2) {
            mvr1.swap (mvr2);
        }


    private:

        typedef typename range_type::const_iterator const_subiterator1_type;
        typedef typename range_type::const_iterator subiterator1_type;
        typedef typename range_type::const_iterator const_subiterator2_type;
        typedef typename range_type::const_iterator subiterator2_type;

    public:
        class const_iterator;
        class iterator;


       
        const_iterator find (size_type i) const {
            return const_iterator (*this, r1_.begin () + i, r2_.begin () + i);
        }
       
        iterator find (size_type i) {
            return iterator (*this, r1_.begin () + i, r2_.begin () + i);
        }

        class const_iterator:
            public container_const_reference<matrix_vector_range>,
            public iterator_base_traits<typename M::const_iterator1::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_1150;

            typedef typename matrix_vector_range::value_type value_type;
            typedef typename matrix_vector_range::difference_type difference_type;
            typedef typename matrix_vector_range::const_reference reference;
            typedef const typename matrix_vector_range::value_type *pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator (const self_type &mvr, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mvr), it1_ (it1), it2_ (it2) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1195 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1196);
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1213);
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1228 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1233 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };

       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }

        class iterator:
            public container_reference<matrix_vector_range>,
            public iterator_base_traits<typename M::iterator1::iterator_category>::template
                        iterator_base<iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_1258;

            typedef typename matrix_vector_range::value_type value_type;
            typedef typename matrix_vector_range::difference_type difference_type;
            typedef typename matrix_vector_range::reference reference;
            typedef typename matrix_vector_range::value_type *pointer;


           
            iterator ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator (self_type &mvr, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (mvr), it1_ (it1), it2_ (it2) {}


           
            iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1300 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1301);
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1318);
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1333 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1338 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        matrix_closure_type data_;
        range_type r1_;
        range_type r2_;
    };


    template <class M>
    struct vector_temporary_traits< matrix_vector_range<M> >
    : vector_temporary_traits< M > {} ;
    template <class M>
    struct vector_temporary_traits< const matrix_vector_range<M> >
    : vector_temporary_traits< M > {} ;


    template<class M>
    class matrix_vector_slice:
        public vector_expression<matrix_vector_slice<M> > {

        typedef matrix_vector_slice<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef basic_range<size_type, difference_type> range_type;
        typedef basic_slice<size_type, difference_type> slice_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;


       
        matrix_vector_slice (matrix_type &data, const slice_type &s1, const slice_type &s2):
            data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {





        }


       
        size_type start1 () const {
            return s1_.start ();
        }
       
        size_type start2 () const {
            return s2_.start ();
        }
       
        difference_type stride1 () const {
            return s1_.stride ();
        }
       
        difference_type stride2 () const {
            return s2_.stride ();
        }
       
        size_type size () const {
            return same_impl_ex ((s1_.size ()), (s2_.size ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1451);
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i) const {
            return data_ (s1_ (i), s2_ (i));
        }
       
        reference operator () (size_type i) {
            return data_ (s1_ (i), s2_ (i));
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }
# 1496 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_vector_slice &operator = (const matrix_vector_slice &mvs) {

            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (mvs));
            return *this;
        }
       
        matrix_vector_slice &assign_temporary (matrix_vector_slice &mvs) {

            vector_assign<scalar_assign> (*this, mvs);
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &operator = (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &operator += (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &operator -= (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_slice &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_vector_slice &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_vector_slice &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_vector_slice &mvs) const {
            return (*this).data_.same_closure (mvs.data_);
        }


       
        bool operator == (const matrix_vector_slice &mvs) const {
            return (*this).data_ == mvs.data_ && s1_ == mvs.s1_ && s2_ == mvs.s2_;
        }


       
        void swap (matrix_vector_slice mvs) {
            if (this != &mvs) {
                if (! (size () == mvs.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1573 << ":" << std::endl; std::cerr << "size () == mvs.size ()" << std::endl; bad_size ().raise (); };


                vector_swap<scalar_swap> (*this, mvs);
            }
        }
       
        friend void swap (matrix_vector_slice mvs1, matrix_vector_slice mvs2) {
            mvs1.swap (mvs2);
        }


    private:

        typedef typename slice_type::const_iterator const_subiterator1_type;
        typedef typename slice_type::const_iterator subiterator1_type;
        typedef typename slice_type::const_iterator const_subiterator2_type;
        typedef typename slice_type::const_iterator subiterator2_type;

    public:
        class const_iterator;
        class iterator;


       
        const_iterator find (size_type i) const {
            return const_iterator (*this, s1_.begin () + i, s2_.begin () + i);
        }
       
        iterator find (size_type i) {
            return iterator (*this, s1_.begin () + i, s2_.begin () + i);
        }



        class const_iterator:
            public container_const_reference<matrix_vector_slice>,
            public iterator_base_traits<typename M::const_iterator1::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_1615;

            typedef typename matrix_vector_slice::value_type value_type;
            typedef typename matrix_vector_slice::difference_type difference_type;
            typedef typename matrix_vector_slice::const_reference reference;
            typedef const typename matrix_vector_slice::value_type *pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator (const self_type &mvs, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mvs), it1_ (it1), it2_ (it2) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1660 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1661);
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1678);
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1693 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1698 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };

       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }

        class iterator:
            public container_reference<matrix_vector_slice>,
            public iterator_base_traits<typename M::iterator1::iterator_category>::template
                        iterator_base<iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_1723;

            typedef typename matrix_vector_slice::value_type value_type;
            typedef typename matrix_vector_slice::difference_type difference_type;
            typedef typename matrix_vector_slice::reference reference;
            typedef typename matrix_vector_slice::value_type *pointer;


           
            iterator ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator (self_type &mvs, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (mvs), it1_ (it1), it2_ (it2) {}


           
            iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1765 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1766);
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1783);
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1798 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 1803 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        matrix_closure_type data_;
        slice_type s1_;
        slice_type s2_;
    };


    template <class M>
    struct vector_temporary_traits< matrix_vector_slice<M> >
    : vector_temporary_traits< M > {} ;
    template <class M>
    struct vector_temporary_traits< const matrix_vector_slice<M> >
    : vector_temporary_traits< M > {} ;


    template<class M, class IA>
    class matrix_vector_indirect:
        public vector_expression<matrix_vector_indirect<M, IA> > {

        typedef matrix_vector_indirect<M, IA> self_type;
    public:



        typedef M matrix_type;
        typedef IA indirect_array_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;


       
        matrix_vector_indirect (matrix_type &data, size_type size):
            data_ (data), ia1_ (size), ia2_ (size) {}
       
        matrix_vector_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2):
            data_ (data), ia1_ (ia1), ia2_ (ia2) {


        }


       
        size_type size () const {
            return same_impl_ex ((ia1_.size ()), (ia2_.size ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 1899);
        }
       
        const indirect_array_type &indirect1 () const {
            return ia1_;
        }
       
        indirect_array_type &indirect1 () {
            return ia1_;
        }
       
        const indirect_array_type &indirect2 () const {
            return ia2_;
        }
       
        indirect_array_type &indirect2 () {
            return ia2_;
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i) const {
            return data_ (ia1_ (i), ia2_ (i));
        }
       
        reference operator () (size_type i) {
            return data_ (ia1_ (i), ia2_ (i));
        }

       
        const_reference operator [] (size_type i) const {
            return (*this) (i);
        }
       
        reference operator [] (size_type i) {
            return (*this) (i);
        }
# 1960 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_vector_indirect &operator = (const matrix_vector_indirect &mvi) {

            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (mvi));
            return *this;
        }
       
        matrix_vector_indirect &assign_temporary (matrix_vector_indirect &mvi) {

            vector_assign<scalar_assign> (*this, mvi);
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &operator = (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &operator += (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &plus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &operator -= (const vector_expression<AE> &ae) {
            vector_assign<scalar_assign> (*this, typename vector_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_vector_indirect &minus_assign (const vector_expression<AE> &ae) {
            vector_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_vector_indirect &operator *= (const AT &at) {
            vector_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_vector_indirect &operator /= (const AT &at) {
            vector_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_vector_indirect &mvi) const {
            return (*this).data_.same_closure (mvi.data_);
        }


       
        bool operator == (const matrix_vector_indirect &mvi) const {
            return (*this).data_ == mvi.data_ && ia1_ == mvi.ia1_ && ia2_ == mvi.ia2_;
        }


       
        void swap (matrix_vector_indirect mvi) {
            if (this != &mvi) {
                if (! (size () == mvi.size ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2037 << ":" << std::endl; std::cerr << "size () == mvi.size ()" << std::endl; bad_size ().raise (); };


                vector_swap<scalar_swap> (*this, mvi);
            }
        }
       
        friend void swap (matrix_vector_indirect mvi1, matrix_vector_indirect mvi2) {
            mvi1.swap (mvi2);
        }


    private:

        typedef typename IA::const_iterator const_subiterator1_type;
        typedef typename IA::const_iterator subiterator1_type;
        typedef typename IA::const_iterator const_subiterator2_type;
        typedef typename IA::const_iterator subiterator2_type;

    public:
        class const_iterator;
        class iterator;


       
        const_iterator find (size_type i) const {
            return const_iterator (*this, ia1_.begin () + i, ia2_.begin () + i);
        }
       
        iterator find (size_type i) {
            return iterator (*this, ia1_.begin () + i, ia2_.begin () + i);
        }



        class const_iterator:
            public container_const_reference<matrix_vector_indirect>,
            public iterator_base_traits<typename M::const_iterator1::iterator_category>::template
                        iterator_base<const_iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_2079;

            typedef typename matrix_vector_indirect::value_type value_type;
            typedef typename matrix_vector_indirect::difference_type difference_type;
            typedef typename matrix_vector_indirect::const_reference reference;
            typedef const typename matrix_vector_indirect::value_type *pointer;


           
            const_iterator ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator (const self_type &mvi, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mvi), it1_ (it1), it2_ (it2) {}
           
            const_iterator (const typename self_type::iterator &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            const_iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            const_iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            const_iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2124 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 2125);
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 2142);
            }


           
            const_iterator &operator = (const const_iterator &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2157 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2162 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };

       
        const_iterator begin () const {
            return find (0);
        }
       
        const_iterator end () const {
            return find (size ());
        }

        class iterator:
            public container_reference<matrix_vector_indirect>,
            public iterator_base_traits<typename M::iterator1::iterator_category>::template
                        iterator_base<iterator, value_type>::type {
        public:


            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((boost::is_same<typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_2187;

            typedef typename matrix_vector_indirect::value_type value_type;
            typedef typename matrix_vector_indirect::difference_type difference_type;
            typedef typename matrix_vector_indirect::reference reference;
            typedef typename matrix_vector_indirect::value_type *pointer;


           
            iterator ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator (self_type &mvi, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (mvi), it1_ (it1), it2_ (it2) {}


           
            iterator &operator ++ () {
                ++ it1_;
                ++ it2_;
                return *this;
            }
           
            iterator &operator -- () {
                -- it1_;
                -- it2_;
                return *this;
            }
           
            iterator &operator += (difference_type n) {
                it1_ += n;
                it2_ += n;
                return *this;
            }
           
            iterator &operator -= (difference_type n) {
                it1_ -= n;
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2229 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return same_impl_ex ((it1_ - it.it1_), (it2_ - it.it2_), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 2230);
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           
            size_type index () const {
                return same_impl_ex ((it1_.index ()), (it2_.index ()), "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp", 2247);
            }


           
            iterator &operator = (const iterator &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2262 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_ && it2_ == it.it2_;
            }
           
            bool operator < (const iterator &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2267 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_ && it2_ < it.it2_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator;
        };

       
        iterator begin () {
            return find (0);
        }
       
        iterator end () {
            return find (size ());
        }


        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
        typedef reverse_iterator_base<iterator> reverse_iterator;

       
        const_reverse_iterator rbegin () const {
            return const_reverse_iterator (end ());
        }
       
        const_reverse_iterator rend () const {
            return const_reverse_iterator (begin ());
        }
       
        reverse_iterator rbegin () {
            return reverse_iterator (end ());
        }
       
        reverse_iterator rend () {
            return reverse_iterator (begin ());
        }

    private:
        matrix_closure_type data_;
        indirect_array_type ia1_;
        indirect_array_type ia2_;
    };


    template <class M, class IA>
    struct vector_temporary_traits< matrix_vector_indirect<M,IA> >
    : vector_temporary_traits< M > {} ;
    template <class M, class IA>
    struct vector_temporary_traits< const matrix_vector_indirect<M,IA> >
    : vector_temporary_traits< M > {} ;


    template<class M>
    class matrix_range:
        public matrix_expression<matrix_range<M> > {

        typedef matrix_range<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef basic_range<size_type, difference_type> range_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;
        typedef typename M::orientation_category orientation_category;


       
        matrix_range (matrix_type &data, const range_type &r1, const range_type &r2):
            data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {





        }
       
        matrix_range (const matrix_closure_type &data, const range_type &r1, const range_type &r2, int):
            data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {





        }


       
        size_type start1 () const {
            return r1_.start ();
        }
       
        size_type size1 () const {
            return r1_.size ();
        }
       
        size_type start2() const {
            return r2_.start ();
        }
       
        size_type size2 () const {
            return r2_.size ();
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i, size_type j) const {
            return data_ (r1_ (i), r2_ (j));
        }
       
        reference operator () (size_type i, size_type j) {
            return data_ (r1_ (i), r2_ (j));
        }
# 2418 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_range<matrix_type> project (const range_type &r1, const range_type &r2) const {
            return matrix_range<matrix_type> (data_, r1_.compose (r1.preprocess (data_.size1 ())), r2_.compose (r2.preprocess (data_.size2 ())), 0);
        }


       
        matrix_range &operator = (const matrix_range &mr) {
            matrix_assign<scalar_assign> (*this, mr);
            return *this;
        }
       
        matrix_range &assign_temporary (matrix_range &mr) {
            return *this = mr;
        }
        template<class AE>
       
        matrix_range &operator = (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_range &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_range& operator += (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_range &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_range& operator -= (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_range &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_range& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_range& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_range &mr) const {
            return (*this).data_.same_closure (mr.data_);
        }


       
        bool operator == (const matrix_range &mr) const {
            return (*this).data_ == (mr.data_) && r1_ == mr.r1_ && r2_ == mr.r2_;
        }


       
        void swap (matrix_range mr) {
            if (this != &mr) {
                if (! (size1 () == mr.size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2498 << ":" << std::endl; std::cerr << "size1 () == mr.size1 ()" << std::endl; bad_size ().raise (); };
                if (! (size2 () == mr.size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2499 << ":" << std::endl; std::cerr << "size2 () == mr.size2 ()" << std::endl; bad_size ().raise (); };
                matrix_swap<scalar_swap> (*this, mr);
            }
        }
       
        friend void swap (matrix_range mr1, matrix_range mr2) {
            mr1.swap (mr2);
        }


    private:
        typedef typename M::const_iterator1 const_subiterator1_type;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_iterator1,
                                          typename M::iterator1>::type subiterator1_type;
        typedef typename M::const_iterator2 const_subiterator2_type;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_iterator2,
                                          typename M::iterator2>::type subiterator2_type;

    public:
# 2530 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int rank, size_type i, size_type j) const {
            const_subiterator1_type it1 (data_.find1 (rank, start1 () + i, start2 () + j));



            return const_iterator1 (*this, it1);

        }
       
        iterator1 find1 (int rank, size_type i, size_type j) {
            subiterator1_type it1 (data_.find1 (rank, start1 () + i, start2 () + j));



            return iterator1 (*this, it1);

        }
       
        const_iterator2 find2 (int rank, size_type i, size_type j) const {
            const_subiterator2_type it2 (data_.find2 (rank, start1 () + i, start2 () + j));



            return const_iterator2 (*this, it2);

        }
       
        iterator2 find2 (int rank, size_type i, size_type j) {
            subiterator2_type it2 (data_.find2 (rank, start1 () + i, start2 () + j));



            return iterator2 (*this, it2);

        }



        class const_iterator1:
            public container_const_reference<matrix_range>,
            public iterator_base_traits<typename const_subiterator1_type::iterator_category>::template
                        iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename const_subiterator1_type::value_type value_type;
            typedef typename const_subiterator1_type::difference_type difference_type;
            typedef typename const_subiterator1_type::reference reference;
            typedef typename const_subiterator1_type::pointer pointer;
            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator1 (const self_type &mr, const const_subiterator1_type &it):
                container_const_reference<self_type> (mr), it_ (it) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator1 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2626 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                const self_type &mr = (*this) ();
                return mr.find2 (1, index1 (), 0);
            }
           



            const_iterator2 end () const {
                const self_type &mr = (*this) ();
                return mr.find2 (1, index1 (), mr.size2 ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 () - (*this) ().start1 ();
            }
           
            size_type index2 () const {
                return it_.index2 () - (*this) ().start2 ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2694 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2699 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator1_type it_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class iterator1:
            public container_reference<matrix_range>,
            public iterator_base_traits<typename subiterator1_type::iterator_category>::template
                        iterator_base<iterator1, value_type>::type {
        public:
            typedef typename subiterator1_type::value_type value_type;
            typedef typename subiterator1_type::difference_type difference_type;
            typedef typename subiterator1_type::reference reference;
            typedef typename subiterator1_type::pointer pointer;
            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), it_ () {}
           
            iterator1 (self_type &mr, const subiterator1_type &it):
                container_reference<self_type> (mr), it_ (it) {}


           
            iterator1 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator1 &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2761 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                self_type &mr = (*this) ();
                return mr.find2 (1, index1 (), 0);
            }
           



            iterator2 end () const {
                self_type &mr = (*this) ();
                return mr.find2 (1, index1 (), mr.size2 ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 () - (*this) ().start1 ();
            }
           
            size_type index2 () const {
                return it_.index2 () - (*this) ().start2 ();
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2829 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2834 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator1_type it_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_range>,
            public iterator_base_traits<typename const_subiterator2_type::iterator_category>::template
                        iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename const_subiterator2_type::value_type value_type;
            typedef typename const_subiterator2_type::difference_type difference_type;
            typedef typename const_subiterator2_type::reference reference;
            typedef typename const_subiterator2_type::pointer pointer;
            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it_ () {}
           
            const_iterator2 (const self_type &mr, const const_subiterator2_type &it):
                container_const_reference<self_type> (mr), it_ (it) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), it_ (it.it_) {}


           
            const_iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2901 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            const_reference operator * () const {
                return *it_;
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                const self_type &mr = (*this) ();
                return mr.find1 (1, 0, index2 ());
            }
           



            const_iterator1 end () const {
                const self_type &mr = (*this) ();
                return mr.find1 (1, mr.size1 (), index2 ());
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 () - (*this) ().start1 ();
            }
           
            size_type index2 () const {
                return it_.index2 () - (*this) ().start2 ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2969 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 2974 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            const_subiterator2_type it_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }


        class iterator2:
            public container_reference<matrix_range>,
            public iterator_base_traits<typename subiterator2_type::iterator_category>::template
                        iterator_base<iterator2, value_type>::type {
        public:
            typedef typename subiterator2_type::value_type value_type;
            typedef typename subiterator2_type::difference_type difference_type;
            typedef typename subiterator2_type::reference reference;
            typedef typename subiterator2_type::pointer pointer;
            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), it_ () {}
           
            iterator2 (self_type &mr, const subiterator2_type &it):
                container_reference<self_type> (mr), it_ (it) {}


           
            iterator2 &operator ++ () {
                ++ it_;
                return *this;
            }
           
            iterator2 &operator -- () {
                -- it_;
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                it_ += n;
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                it_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
               if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3036 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ - it.it_;
            }


           
            reference operator * () const {
                return *it_;
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                self_type &mr = (*this) ();
                return mr.find1 (1, 0, index2 ());
            }
           



            iterator1 end () const {
                self_type &mr = (*this) ();
                return mr.find1 (1, mr.size1 (), index2 ());
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it_.index1 () - (*this) ().start1 ();
            }
           
            size_type index2 () const {
                return it_.index2 () - (*this) ().start2 ();
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it_ = it.it_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3104 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ == it.it_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3109 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                return it_ < it.it_;
            }

        private:
            subiterator2_type it_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }

    private:
        matrix_closure_type data_;
        range_type r1_;
        range_type r2_;
    };


    template<class M>
   
    matrix_range<M> subrange (M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2) {
        typedef basic_range<typename M::size_type, typename M::difference_type> range_type;
        return matrix_range<M> (data, range_type (start1, stop1), range_type (start2, stop2));
    }
    template<class M>
   
    matrix_range<const M> subrange (const M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2) {
        typedef basic_range<typename M::size_type, typename M::difference_type> range_type;
        return matrix_range<const M> (data, range_type (start1, stop1), range_type (start2, stop2));
    }


    template<class M>
   
    matrix_range<M> project (M &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {
        return matrix_range<M> (data, r1, r2);
    }
    template<class M>
   
    const matrix_range<const M> project (const M &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {

        return matrix_range<const M> (data, r1, r2);
    }
    template<class M>
   
    matrix_range<M> project (matrix_range<M> &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {
        return data.project (r1, r2);
    }
    template<class M>
   
    const matrix_range<M> project (const matrix_range<M> &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {
        return data.project (r1, r2);
    }


    template <class M>
    struct matrix_temporary_traits< matrix_range<M> >
    : matrix_temporary_traits< M > {} ;
    template <class M>
    struct matrix_temporary_traits< const matrix_range<M> >
    : matrix_temporary_traits< M > {} ;

    template <class M>
    struct vector_temporary_traits< matrix_range<M> >
    : vector_temporary_traits< M > {} ;
    template <class M>
    struct vector_temporary_traits< const matrix_range<M> >
    : vector_temporary_traits< M > {} ;


    template<class M>
    class matrix_slice:
        public matrix_expression<matrix_slice<M> > {

        typedef matrix_slice<M> self_type;
    public:



        typedef M matrix_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef basic_range<size_type, difference_type> range_type;
        typedef basic_slice<size_type, difference_type> slice_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;
        typedef typename M::orientation_category orientation_category;


       
        matrix_slice (matrix_type &data, const slice_type &s1, const slice_type &s2):
            data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {





        }
       
        matrix_slice (const matrix_closure_type &data, const slice_type &s1, const slice_type &s2, int):
            data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {





        }


       
        size_type start1 () const {
            return s1_.start ();
        }
       
        size_type start2 () const {
            return s2_.start ();
        }
       
        difference_type stride1 () const {
            return s1_.stride ();
        }
       
        difference_type stride2 () const {
            return s2_.stride ();
        }
       
        size_type size1 () const {
            return s1_.size ();
        }
       
        size_type size2 () const {
            return s2_.size ();
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i, size_type j) const {
            return data_ (s1_ (i), s2_ (j));
        }
       
        reference operator () (size_type i, size_type j) {
            return data_ (s1_ (i), s2_ (j));
        }
# 3330 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_slice<matrix_type> project (const range_type &r1, const range_type &r2) const {
            return matrix_slice<matrix_type> (data_, s1_.compose (r1.preprocess (data_.size1 ())), s2_.compose (r2.preprocess (data_.size2 ())), 0);
        }
       
        matrix_slice<matrix_type> project (const slice_type &s1, const slice_type &s2) const {
            return matrix_slice<matrix_type> (data_, s1_.compose (s1.preprocess (data_.size1 ())), s2_.compose (s2.preprocess (data_.size2 ())), 0);
        }


       
        matrix_slice &operator = (const matrix_slice &ms) {
            matrix_assign<scalar_assign> (*this, ms);
            return *this;
        }
       
        matrix_slice &assign_temporary (matrix_slice &ms) {
            return *this = ms;
        }
        template<class AE>
       
        matrix_slice &operator = (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_slice &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_slice& operator += (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_slice &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_slice& operator -= (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_slice &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_slice& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_slice& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_slice &ms) const {
            return (*this).data_.same_closure (ms.data_);
        }


       
        bool operator == (const matrix_slice &ms) const {
            return (*this).data_ == ms.data_ && s1_ == ms.s1_ && s2_ == ms.s2_;
        }


       
        void swap (matrix_slice ms) {
            if (this != &ms) {
                if (! (size1 () == ms.size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3414 << ":" << std::endl; std::cerr << "size1 () == ms.size1 ()" << std::endl; bad_size ().raise (); };
                if (! (size2 () == ms.size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3415 << ":" << std::endl; std::cerr << "size2 () == ms.size2 ()" << std::endl; bad_size ().raise (); };
                matrix_swap<scalar_swap> (*this, ms);
            }
        }
       
        friend void swap (matrix_slice ms1, matrix_slice ms2) {
            ms1.swap (ms2);
        }


    private:

        typedef typename slice_type::const_iterator const_subiterator1_type;
        typedef typename slice_type::const_iterator subiterator1_type;
        typedef typename slice_type::const_iterator const_subiterator2_type;
        typedef typename slice_type::const_iterator subiterator2_type;

    public:
# 3443 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {



            return const_iterator1 (*this, s1_.begin () + i, s2_.begin () + j);

        }
       
        iterator1 find1 (int , size_type i, size_type j) {



            return iterator1 (*this, s1_.begin () + i, s2_.begin () + j);

        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {



            return const_iterator2 (*this, s1_.begin () + i, s2_.begin () + j);

        }
       
        iterator2 find2 (int , size_type i, size_type j) {



            return iterator2 (*this, s1_.begin () + i, s2_.begin () + j);

        }




        class const_iterator1:
            public container_const_reference<matrix_slice>,
            public iterator_base_traits<typename M::const_iterator1::iterator_category>::template
                        iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename M::const_iterator1::value_type value_type;
            typedef typename M::const_iterator1::difference_type difference_type;
            typedef typename M::const_reference reference;
            typedef typename M::const_iterator1::pointer pointer;
            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &ms, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (ms), it1_ (it1), it2_ (it2) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3536 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3537 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return const_iterator2 ((*this) (), it1_, it2_ ().begin ());
            }
           



            const_iterator2 end () const {
                return const_iterator2 ((*this) (), it1_, it2_ ().end ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3605 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3606 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3611 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3612 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class iterator1:
            public container_reference<matrix_slice>,
            public iterator_base_traits<typename M::iterator1::iterator_category>::template
                        iterator_base<iterator1, value_type>::type {
        public:
            typedef typename M::iterator1::value_type value_type;
            typedef typename M::iterator1::difference_type difference_type;
            typedef typename M::reference reference;
            typedef typename M::iterator1::pointer pointer;
            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator1 (self_type &ms, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (ms), it1_ (it1), it2_ (it2) {}


           
            iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3675 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3676 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                return iterator2 ((*this) (), it1_, it2_ ().begin ());
            }
           



            iterator2 end () const {
                return iterator2 ((*this) (), it1_, it2_ ().end ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3744 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3745 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3750 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3751 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_slice>,
            public iterator_base_traits<typename M::const_iterator2::iterator_category>::template
                        iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename M::const_iterator2::value_type value_type;
            typedef typename M::const_iterator2::difference_type difference_type;
            typedef typename M::const_reference reference;
            typedef typename M::const_iterator2::pointer pointer;
            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &ms, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (ms), it1_ (it1), it2_ (it2) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3819 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3820 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return const_iterator1 ((*this) (), it1_ ().begin (), it2_);
            }
           



            const_iterator1 end () const {
                return const_iterator1 ((*this) (), it1_ ().end (), it2_);
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3888 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3889 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3894 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3895 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }


        class iterator2:
            public container_reference<matrix_slice>,
            public iterator_base_traits<typename M::iterator2::iterator_category>::template
                        iterator_base<iterator2, value_type>::type {
        public:
            typedef typename M::iterator2::value_type value_type;
            typedef typename M::iterator2::difference_type difference_type;
            typedef typename M::reference reference;
            typedef typename M::iterator2::pointer pointer;
            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator2 (self_type &ms, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (ms), it1_ (it1), it2_ (it2) {}


           
            iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3958 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 3959 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                return iterator1 ((*this) (), it1_ ().begin (), it2_);
            }
           



            iterator1 end () const {
                return iterator1 ((*this) (), it1_ ().end (), it2_);
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4027 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4028 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4033 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4034 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }

    private:
        matrix_closure_type data_;
        slice_type s1_;
        slice_type s2_;
    };


    template<class M>
   
    matrix_slice<M> subslice (M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2) {
        typedef basic_slice<typename M::size_type, typename M::difference_type> slice_type;
        return matrix_slice<M> (data, slice_type (start1, stride1, size1), slice_type (start2, stride2, size2));
    }
    template<class M>
   
    matrix_slice<const M> subslice (const M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2) {
        typedef basic_slice<typename M::size_type, typename M::difference_type> slice_type;
        return matrix_slice<const M> (data, slice_type (start1, stride1, size1), slice_type (start2, stride2, size2));
    }


    template<class M>
   
    matrix_slice<M> project (M &data, const typename matrix_slice<M>::slice_type &s1, const typename matrix_slice<M>::slice_type &s2) {
        return matrix_slice<M> (data, s1, s2);
    }
    template<class M>
   
    const matrix_slice<const M> project (const M &data, const typename matrix_slice<M>::slice_type &s1, const typename matrix_slice<M>::slice_type &s2) {

        return matrix_slice<const M> (data, s1, s2);
    }

    template<class M>
   
    matrix_slice<M> project (matrix_slice<M> &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {
        return data.project (r1, r2);
    }
    template<class M>
   
    const matrix_slice<M> project (const matrix_slice<M> &data, const typename matrix_range<M>::range_type &r1, const typename matrix_range<M>::range_type &r2) {
        return data.project (r1, r2);
    }
    template<class M>
   
    matrix_slice<M> project (matrix_slice<M> &data, const typename matrix_slice<M>::slice_type &s1, const typename matrix_slice<M>::slice_type &s2) {
        return data.project (s1, s2);
    }
    template<class M>
   
    const matrix_slice<M> project (const matrix_slice<M> &data, const typename matrix_slice<M>::slice_type &s1, const typename matrix_slice<M>::slice_type &s2) {
        return data.project (s1, s2);
    }


    template <class M>
    struct matrix_temporary_traits< matrix_slice<M> >
    : matrix_temporary_traits< M > {};
    template <class M>
    struct matrix_temporary_traits< const matrix_slice<M> >
    : matrix_temporary_traits< M > {};

    template <class M>
    struct vector_temporary_traits< matrix_slice<M> >
    : vector_temporary_traits< M > {};
    template <class M>
    struct vector_temporary_traits< const matrix_slice<M> >
    : vector_temporary_traits< M > {};




    template<class M, class IA>
    class matrix_indirect:
        public matrix_expression<matrix_indirect<M, IA> > {

        typedef matrix_indirect<M, IA> self_type;
    public:



        typedef M matrix_type;
        typedef IA indirect_array_type;
        typedef typename M::size_type size_type;
        typedef typename M::difference_type difference_type;
        typedef typename M::value_type value_type;
        typedef typename M::const_reference const_reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_reference,
                                          typename M::reference>::type reference;
        typedef typename boost::mpl::if_<boost::is_const<M>,
                                          typename M::const_closure_type,
                                          typename M::closure_type>::type matrix_closure_type;
        typedef basic_range<size_type, difference_type> range_type;
        typedef basic_slice<size_type, difference_type> slice_type;
        typedef const self_type const_closure_type;
        typedef self_type closure_type;
        typedef typename storage_restrict_traits<typename M::storage_category,
                                                 dense_proxy_tag>::storage_category storage_category;
        typedef typename M::orientation_category orientation_category;


       
        matrix_indirect (matrix_type &data, size_type size1, size_type size2):
            data_ (data), ia1_ (size1), ia2_ (size2) {}
       
        matrix_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2):
            data_ (data), ia1_ (ia1.preprocess (data.size1 ())), ia2_ (ia2.preprocess (data.size2 ())) {}
       
        matrix_indirect (const matrix_closure_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2, int):
            data_ (data), ia1_ (ia1.preprocess (data.size1 ())), ia2_ (ia2.preprocess (data.size2 ())) {}


       
        size_type size1 () const {
            return ia1_.size ();
        }
       
        size_type size2 () const {
            return ia2_.size ();
        }
       
        const indirect_array_type &indirect1 () const {
            return ia1_;
        }
       
        indirect_array_type &indirect1 () {
            return ia1_;
        }
       
        const indirect_array_type &indirect2 () const {
            return ia2_;
        }
       
        indirect_array_type &indirect2 () {
            return ia2_;
        }


       
        const matrix_closure_type &data () const {
            return data_;
        }
       
        matrix_closure_type &data () {
            return data_;
        }



       
        const_reference operator () (size_type i, size_type j) const {
            return data_ (ia1_ (i), ia2_ (j));
        }
       
        reference operator () (size_type i, size_type j) {
            return data_ (ia1_ (i), ia2_ (j));
        }
# 4261 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
       
        matrix_indirect<matrix_type, indirect_array_type> project (const range_type &r1, const range_type &r2) const {
            return matrix_indirect<matrix_type, indirect_array_type> (data_, ia1_.compose (r1.preprocess (data_.size1 ())), ia2_.compose (r2.preprocess (data_.size2 ())), 0);
        }
       
        matrix_indirect<matrix_type, indirect_array_type> project (const slice_type &s1, const slice_type &s2) const {
            return matrix_indirect<matrix_type, indirect_array_type> (data_, ia1_.compose (s1.preprocess (data_.size1 ())), ia2_.compose (s2.preprocess (data_.size2 ())), 0);
        }
       
        matrix_indirect<matrix_type, indirect_array_type> project (const indirect_array_type &ia1, const indirect_array_type &ia2) const {
            return matrix_indirect<matrix_type, indirect_array_type> (data_, ia1_.compose (ia1.preprocess (data_.size1 ())), ia2_.compose (ia2.preprocess (data_.size2 ())), 0);
        }


       
        matrix_indirect &operator = (const matrix_indirect &mi) {
            matrix_assign<scalar_assign> (*this, mi);
            return *this;
        }
       
        matrix_indirect &assign_temporary (matrix_indirect &mi) {
            return *this = mi;
        }
        template<class AE>
       
        matrix_indirect &operator = (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (ae));
            return *this;
        }
        template<class AE>
       
        matrix_indirect &assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_indirect& operator += (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this + ae));
            return *this;
        }
        template<class AE>
       
        matrix_indirect &plus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_plus_assign> (*this, ae);
            return *this;
        }
        template<class AE>
       
        matrix_indirect& operator -= (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_assign> (*this, typename matrix_temporary_traits<M>::type (*this - ae));
            return *this;
        }
        template<class AE>
       
        matrix_indirect &minus_assign (const matrix_expression<AE> &ae) {
            matrix_assign<scalar_minus_assign> (*this, ae);
            return *this;
        }
        template<class AT>
       
        matrix_indirect& operator *= (const AT &at) {
            matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
            return *this;
        }
        template<class AT>
       
        matrix_indirect& operator /= (const AT &at) {
            matrix_assign_scalar<scalar_divides_assign> (*this, at);
            return *this;
        }


       
        bool same_closure (const matrix_indirect &mi) const {
            return (*this).data_.same_closure (mi.data_);
        }


       
        bool operator == (const matrix_indirect &mi) const {
            return (*this).data_ == mi.data_ && ia1_ == mi.ia1_ && ia2_ == mi.ia2_;
        }


       
        void swap (matrix_indirect mi) {
            if (this != &mi) {
                if (! (size1 () == mi.size1 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4349 << ":" << std::endl; std::cerr << "size1 () == mi.size1 ()" << std::endl; bad_size ().raise (); };
                if (! (size2 () == mi.size2 ())) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4350 << ":" << std::endl; std::cerr << "size2 () == mi.size2 ()" << std::endl; bad_size ().raise (); };
                matrix_swap<scalar_swap> (*this, mi);
            }
        }
       
        friend void swap (matrix_indirect mi1, matrix_indirect mi2) {
            mi1.swap (mi2);
        }


    private:
        typedef typename IA::const_iterator const_subiterator1_type;
        typedef typename IA::const_iterator subiterator1_type;
        typedef typename IA::const_iterator const_subiterator2_type;
        typedef typename IA::const_iterator subiterator2_type;

    public:
# 4377 "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp"
        class const_iterator1;
        class iterator1;
        class const_iterator2;
        class iterator2;

        typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
        typedef reverse_iterator_base1<iterator1> reverse_iterator1;
        typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
        typedef reverse_iterator_base2<iterator2> reverse_iterator2;


       
        const_iterator1 find1 (int , size_type i, size_type j) const {



            return const_iterator1 (*this, ia1_.begin () + i, ia2_.begin () + j);

        }
       
        iterator1 find1 (int , size_type i, size_type j) {



            return iterator1 (*this, ia1_.begin () + i, ia2_.begin () + j);

        }
       
        const_iterator2 find2 (int , size_type i, size_type j) const {



            return const_iterator2 (*this, ia1_.begin () + i, ia2_.begin () + j);

        }
       
        iterator2 find2 (int , size_type i, size_type j) {



            return iterator2 (*this, ia1_.begin () + i, ia2_.begin () + j);

        }




        class const_iterator1:
            public container_const_reference<matrix_indirect>,
            public iterator_base_traits<typename M::const_iterator1::iterator_category>::template
                        iterator_base<const_iterator1, value_type>::type {
        public:
            typedef typename M::const_iterator1::value_type value_type;
            typedef typename M::const_iterator1::difference_type difference_type;
            typedef typename M::const_reference reference;
            typedef typename M::const_iterator1::pointer pointer;
            typedef const_iterator2 dual_iterator_type;
            typedef const_reverse_iterator2 dual_reverse_iterator_type;


           
            const_iterator1 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator1 (const self_type &mi, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mi), it1_ (it1), it2_ (it2) {}
           
            const_iterator1 (const iterator1 &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            const_iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            const_iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            const_iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4470 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4471 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator2 begin () const {
                return const_iterator2 ((*this) (), it1_, it2_ ().begin ());
            }
           



            const_iterator2 end () const {
                return const_iterator2 ((*this) (), it1_, it2_ ().end ());
            }
           



            const_reverse_iterator2 rbegin () const {
                return const_reverse_iterator2 (end ());
            }
           



            const_reverse_iterator2 rend () const {
                return const_reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator1 &operator = (const const_iterator1 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4539 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4540 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const const_iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4545 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4546 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator1 begin1 () const {
            return find1 (0, 0, 0);
        }
       
        const_iterator1 end1 () const {
            return find1 (0, size1 (), 0);
        }


        class iterator1:
            public container_reference<matrix_indirect>,
            public iterator_base_traits<typename M::iterator1::iterator_category>::template
                        iterator_base<iterator1, value_type>::type {
        public:
            typedef typename M::iterator1::value_type value_type;
            typedef typename M::iterator1::difference_type difference_type;
            typedef typename M::reference reference;
            typedef typename M::iterator1::pointer pointer;
            typedef iterator2 dual_iterator_type;
            typedef reverse_iterator2 dual_reverse_iterator_type;


           
            iterator1 ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator1 (self_type &mi, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (mi), it1_ (it1), it2_ (it2) {}


           
            iterator1 &operator ++ () {
                ++ it1_;
                return *this;
            }
           
            iterator1 &operator -- () {
                -- it1_;
                return *this;
            }
           
            iterator1 &operator += (difference_type n) {
                it1_ += n;
                return *this;
            }
           
            iterator1 &operator -= (difference_type n) {
                it1_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4609 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4610 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ - it.it1_;
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator2 begin () const {
                return iterator2 ((*this) (), it1_, it2_ ().begin ());
            }
           



            iterator2 end () const {
                return iterator2 ((*this) (), it1_, it2_ ().end ());
            }
           



            reverse_iterator2 rbegin () const {
                return reverse_iterator2 (end ());
            }
           



            reverse_iterator2 rend () const {
                return reverse_iterator2 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            iterator1 &operator = (const iterator1 &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4678 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4679 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ == it.it1_;
            }
           
            bool operator < (const iterator1 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4684 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it2_ == it.it2_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4685 << ":" << std::endl; std::cerr << "it2_ == it.it2_" << std::endl; external_logic ().raise (); };
                return it1_ < it.it1_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator1;
        };


       
        iterator1 begin1 () {
            return find1 (0, 0, 0);
        }
       
        iterator1 end1 () {
            return find1 (0, size1 (), 0);
        }


        class const_iterator2:
            public container_const_reference<matrix_indirect>,
            public iterator_base_traits<typename M::const_iterator2::iterator_category>::template
                        iterator_base<const_iterator2, value_type>::type {
        public:
            typedef typename M::const_iterator2::value_type value_type;
            typedef typename M::const_iterator2::difference_type difference_type;
            typedef typename M::const_reference reference;
            typedef typename M::const_iterator2::pointer pointer;
            typedef const_iterator1 dual_iterator_type;
            typedef const_reverse_iterator1 dual_reverse_iterator_type;


           
            const_iterator2 ():
                container_const_reference<self_type> (), it1_ (), it2_ () {}
           
            const_iterator2 (const self_type &mi, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
                container_const_reference<self_type> (mi), it1_ (it1), it2_ (it2) {}
           
            const_iterator2 (const iterator2 &it):
                container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}


           
            const_iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            const_iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            const_iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            const_iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4753 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4754 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            const_reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            const_reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            const_iterator1 begin () const {
                return const_iterator1 ((*this) (), it1_ ().begin (), it2_);
            }
           



            const_iterator1 end () const {
                return const_iterator1 ((*this) (), it1_ ().end (), it2_);
            }
           



            const_reverse_iterator1 rbegin () const {
                return const_reverse_iterator1 (end ());
            }
           



            const_reverse_iterator1 rend () const {
                return const_reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            const_iterator2 &operator = (const const_iterator2 &it) {
                container_const_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4822 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4823 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const const_iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4828 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4829 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            const_subiterator1_type it1_;
            const_subiterator2_type it2_;
        };


       
        const_iterator2 begin2 () const {
            return find2 (0, 0, 0);
        }
       
        const_iterator2 end2 () const {
            return find2 (0, 0, size2 ());
        }


        class iterator2:
            public container_reference<matrix_indirect>,
            public iterator_base_traits<typename M::iterator2::iterator_category>::template
                        iterator_base<iterator2, value_type>::type {
        public:
            typedef typename M::iterator2::value_type value_type;
            typedef typename M::iterator2::difference_type difference_type;
            typedef typename M::reference reference;
            typedef typename M::iterator2::pointer pointer;
            typedef iterator1 dual_iterator_type;
            typedef reverse_iterator1 dual_reverse_iterator_type;


           
            iterator2 ():
                container_reference<self_type> (), it1_ (), it2_ () {}
           
            iterator2 (self_type &mi, const subiterator1_type &it1, const subiterator2_type &it2):
                container_reference<self_type> (mi), it1_ (it1), it2_ (it2) {}


           
            iterator2 &operator ++ () {
                ++ it2_;
                return *this;
            }
           
            iterator2 &operator -- () {
                -- it2_;
                return *this;
            }
           
            iterator2 &operator += (difference_type n) {
                it2_ += n;
                return *this;
            }
           
            iterator2 &operator -= (difference_type n) {
                it2_ -= n;
                return *this;
            }
           
            difference_type operator - (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4892 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4893 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ - it.it2_;
            }


           
            reference operator * () const {

                return (*this) ().data_ (*it1_, *it2_);
            }
           
            reference operator [] (difference_type n) const {
                return *(*this + n);
            }


           



            iterator1 begin () const {
                return iterator1 ((*this) (), it1_ ().begin (), it2_);
            }
           



            iterator1 end () const {
                return iterator1 ((*this) (), it1_ ().end (), it2_);
            }
           



            reverse_iterator1 rbegin () const {
                return reverse_iterator1 (end ());
            }
           



            reverse_iterator1 rend () const {
                return reverse_iterator1 (begin ());
            }



           
            size_type index1 () const {
                return it1_.index ();
            }
           
            size_type index2 () const {
                return it2_.index ();
            }


           
            iterator2 &operator = (const iterator2 &it) {
                container_reference<self_type>::assign (&it ());
                it1_ = it.it1_;
                it2_ = it.it2_;
                return *this;
            }


           
            bool operator == (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4961 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4962 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ == it.it2_;
            }
           
            bool operator < (const iterator2 &it) const {
                if (! ((*this) ().same_closure (it ()))) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4967 << ":" << std::endl; std::cerr << "(*this) ().same_closure (it ())" << std::endl; external_logic ().raise (); };
                if (! (it1_ == it.it1_)) { std::cerr << "Check failed in file " << "/usr/include/boost-1_41/boost/numeric/ublas/matrix_proxy.hpp" << " at line " << 4968 << ":" << std::endl; std::cerr << "it1_ == it.it1_" << std::endl; external_logic ().raise (); };
                return it2_ < it.it2_;
            }

        private:
            subiterator1_type it1_;
            subiterator2_type it2_;

            friend class const_iterator2;
        };


       
        iterator2 begin2 () {
            return find2 (0, 0, 0);
        }
       
        iterator2 end2 () {
            return find2 (0, 0, size2 ());
        }



       
        const_reverse_iterator1 rbegin1 () const {
            return const_reverse_iterator1 (end1 ());
        }
       
        const_reverse_iterator1 rend1 () const {
            return const_reverse_iterator1 (begin1 ());
        }

       
        reverse_iterator1 rbegin1 () {
            return reverse_iterator1 (end1 ());
        }
       
        reverse_iterator1 rend1 () {
            return reverse_iterator1 (begin1 ());
        }

       
        const_reverse_iterator2 rbegin2 () const {
            return const_reverse_iterator2 (end2 ());
        }
       
        const_reverse_iterator2 rend2 () const {
            return const_reverse_iterator2 (begin2 ());
        }

       
        reverse_iterator2 rbegin2 () {
            return reverse_iterator2 (end2 ());
        }
       
        reverse_iterator2 rend2 () {
            return reverse_iterator2 (begin2 ());
        }

    private:
        matrix_closure_type data_;
        indirect_array_type ia1_;
        indirect_array_type ia2_;
    };


    template<class M, class A>
   
    matrix_indirect<M, indirect_array<A> > project (M &data, const indirect_array<A> &ia1, const indirect_array<A> &ia2) {
        return matrix_indirect<M, indirect_array<A> > (data, ia1, ia2);
    }
    template<class M, class A>
   
    const matrix_indirect<const M, indirect_array<A> > project (const M &data, const indirect_array<A> &ia1, const indirect_array<A> &ia2) {

        return matrix_indirect<const M, indirect_array<A> > (data, ia1, ia2);
    }
    template<class M, class IA>
   
    matrix_indirect<M, IA> project (matrix_indirect<M, IA> &data, const typename matrix_indirect<M, IA>::range_type &r1, const typename matrix_indirect<M, IA>::range_type &r2) {
        return data.project (r1, r2);
    }
    template<class M, class IA>
   
    const matrix_indirect<M, IA> project (const matrix_indirect<M, IA> &data, const typename matrix_indirect<M, IA>::range_type &r1, const typename matrix_indirect<M, IA>::range_type &r2) {
        return data.project (r1, r2);
    }
    template<class M, class IA>
   
    matrix_indirect<M, IA> project (matrix_indirect<M, IA> &data, const typename matrix_indirect<M, IA>::slice_type &s1, const typename matrix_indirect<M, IA>::slice_type &s2) {
        return data.project (s1, s2);
    }
    template<class M, class IA>
   
    const matrix_indirect<M, IA> project (const matrix_indirect<M, IA> &data, const typename matrix_indirect<M, IA>::slice_type &s1, const typename matrix_indirect<M, IA>::slice_type &s2) {
        return data.project (s1, s2);
    }
    template<class M, class A>
   
    matrix_indirect<M, indirect_array<A> > project (matrix_indirect<M, indirect_array<A> > &data, const indirect_array<A> &ia1, const indirect_array<A> &ia2) {
        return data.project (ia1, ia2);
    }
    template<class M, class A>
   
    const matrix_indirect<M, indirect_array<A> > project (const matrix_indirect<M, indirect_array<A> > &data, const indirect_array<A> &ia1, const indirect_array<A> &ia2) {
        return data.project (ia1, ia2);
    }


    template <class M>
    struct matrix_temporary_traits< matrix_indirect<M> >
    : matrix_temporary_traits< M > {};
    template <class M>
    struct matrix_temporary_traits< const matrix_indirect<M> >
    : matrix_temporary_traits< M > {};

    template <class M>
    struct vector_temporary_traits< matrix_indirect<M> >
    : vector_temporary_traits< M > {};
    template <class M>
    struct vector_temporary_traits< const matrix_indirect<M> >
    : vector_temporary_traits< M > {};

}}}
# 33 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp" 2

namespace rw { namespace math {
# 59 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
    template<class T = double>
    class Rotation3D
    {
    public:

        typedef boost::numeric::ublas::bounded_matrix<T, 3, 3> Base;




        Rotation3D() : _matrix(3, 3)
        {}
# 96 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        Rotation3D(
            T r11, T r12, T r13,
            T r21, T r22, T r23,
            T r31, T r32, T r33) : _matrix(3,3)
        {
            m()(0, 0) = r11;
            m()(0, 1) = r12;
            m()(0, 2) = r13;
            m()(1, 0) = r21;
            m()(1, 1) = r22;
            m()(1, 2) = r23;
            m()(2, 0) = r31;
            m()(2, 1) = r32;
            m()(2, 2) = r33;
        }
# 126 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        Rotation3D(
            const Vector3D<T>& i,
            const Vector3D<T>& j,
            const Vector3D<T>& k) : _matrix(3,3)
        {
            m()(0,0) = i[0];
            m()(0,1) = j[0];
            m()(0,2) = k[0];
            m()(1,0) = i[1];
            m()(1,1) = j[1];
            m()(1,2) = k[1];
            m()(2,0) = i[2];
            m()(2,1) = j[2];
            m()(2,2) = k[2];
        }
# 157 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        static const Rotation3D& identity()
        {
            static Rotation3D id(
                boost::numeric::ublas::identity_matrix<T>(3));
            return id;
        }
# 171 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        void normalize() {
            T eps00,eps01,eps02,eps11,eps12,eps22,prod0,prod1,prod2,prod;
            prod0= m()(0, 0)* m()(0, 0)+ m()(1, 0)* m()(1, 0)+ m()(2, 0)* m()(2, 0);
            eps00=((T)1.0-prod0)/prod0;
            prod1= m()(0, 1)* m()(0, 1)+ m()(1, 1)* m()(1, 1)+ m()(2, 1)* m()(2, 1);
            eps11=((T)1.0-prod1)/prod1;
            prod2= m()(0, 2)* m()(0, 2)+ m()(1, 2)* m()(1, 2)+ m()(2, 2)* m()(2, 2);
            eps22=((T)1.0-prod2)/prod2;
            prod=m()(0, 0)* m()(0, 1)+ m()(1, 0)* m()(1, 1)+ m()(2, 0)* m()(2, 1);
            eps01=-prod/(prod0+prod1);
            prod=m()(0, 0)* m()(0, 2)+ m()(1, 0)* m()(1, 2)+ m()(2, 0)* m()(2, 2);
            eps02=-prod/(prod0+prod2);
            prod=m()(0, 1)* m()(0, 2)+ m()(1, 1)* m()(1, 2)+ m()(2, 1)* m()(2, 2);
            eps12=-prod/(prod1+prod2);
            m()(0,0)+=eps00*m()(0,0)+ eps01*m()(0,1)+ eps02*m()(0,2);
            m()(1,0)+=eps00*m()(1,0)+ eps01*m()(1,1)+ eps02*m()(1,2);
            m()(2,0)+=eps00*m()(2,0)+ eps01*m()(2,1)+ eps02*m()(2,2);
            m()(0,1)+=eps01*m()(0,0)+ eps11*m()(0,1)+ eps12*m()(0,2);
            m()(1,1)+=eps01*m()(1,0)+ eps11*m()(1,1)+ eps12*m()(1,2);
            m()(2,1)+=eps01*m()(2,0)+ eps11*m()(2,1)+ eps12*m()(2,2);
            m()(0,2)+=eps02*m()(0,0)+ eps12*m()(0,1)+ eps22*m()(0,2);
            m()(1,2)+=eps02*m()(1,0)+ eps12*m()(1,1)+ eps22*m()(1,2);
            m()(2,2)+=eps02*m()(2,0)+ eps12*m()(2,1)+ eps22*m()(2,2);
        }
# 203 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        T& operator()(size_t row, size_t column)
        {
            return m()(row, column);
        }







        const T& operator()(size_t row, size_t column) const
        {
            return m()(row, column);
        }


        const Vector3D<T> getCol(size_t col) const {
            ((col < 3) ? (void)0 : rw::common::IOUtil::rwAssert("col < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp", 221));
            return Vector3D<T>(m()(0,col),m()(1,col),m()(2,col));
        }
# 234 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        bool operator==(const Rotation3D<> &rhs) const {
            for (int i = 0; i<3; i++)
                for (int j = 0; j<3; j++)
                    if (m()(i,j) == rhs(i,j))
                        return false;
            return true;
        }
# 252 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        bool equal(const Rotation3D<>& rot, T precision) {
            for (int i = 0; i<3; i++)
                for (int j = 0; j<3; j++)
                    if (fabs(m()(i,j) - rot(i,j)) > precision)
                        return false;
            return true;
        }







        const Base& m() const
        {
            return _matrix;
        }







        Base& m()
        {
            return _matrix;
        }
# 292 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        friend const Rotation3D operator*(const Rotation3D& aRb, const Rotation3D& bRc)
        {
            return multiply(aRb, bRc);

        }
# 306 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        friend const Vector3D<T> operator*(const Rotation3D& aRb, const Vector3D<T>& bVc)
        {
            return multiply(aRb, bVc);

        }
# 321 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        template <class R>
        explicit Rotation3D(const boost::numeric::ublas::matrix_expression<R>& r) : _matrix(r)
        {}
# 333 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
        static Rotation3D<T> skew(const Vector3D<T>& v)
        {
                return Rotation3D<T> (0, -v(2), v(1), v(2), 0, -v(0), -v(1), v(0), 0);
        }

    public:






        static inline void multiply(const Rotation3D<T>& a,
                                    const Rotation3D<T>& b,
                                    Rotation3D<T>& result)
        {
            const T a00 = a(0, 0);
            const T a01 = a(0, 1);
            const T a02 = a(0, 2);

            const T a10 = a(1, 0);
            const T a11 = a(1, 1);
            const T a12 = a(1, 2);

            const T a20 = a(2, 0);
            const T a21 = a(2, 1);
            const T a22 = a(2, 2);

            const T b00 = b(0, 0);
            const T b01 = b(0, 1);
            const T b02 = b(0, 2);

            const T b10 = b(1, 0);
            const T b11 = b(1, 1);
            const T b12 = b(1, 2);

            const T b20 = b(2, 0);
            const T b21 = b(2, 1);
            const T b22 = b(2, 2);

            result(0, 0) = a00 * b00 + a01 * b10 + a02 * b20;

            result(0, 1) = a00 * b01 + a01 * b11 + a02 * b21;

            result(0, 2) = a00 * b02 + a01 * b12 + a02 * b22;

            result(1, 0) = a10 * b00 + a11 * b10 + a12 * b20;

            result(1, 1) = a10 * b01 + a11 * b11 + a12 * b21;

            result(1, 2) = a10 * b02 + a11 * b12 + a12 * b22;

            result(2, 0) = a20 * b00 + a21 * b10 + a22 * b20;

            result(2, 1) = a20 * b01 + a21 * b11 + a22 * b21;

            result(2, 2) = a20 * b02 + a21 * b12 + a22 * b22;
        }





        static inline void multiply(const Rotation3D<T>& a,
                                    const Vector3D<T>& b,
                                    Vector3D<T>& result)
        {
            const T a00 = a(0, 0);
            const T a01 = a(0, 1);
            const T a02 = a(0, 2);

            const T a10 = a(1, 0);
            const T a11 = a(1, 1);
            const T a12 = a(1, 2);

            const T a20 = a(2, 0);
            const T a21 = a(2, 1);
            const T a22 = a(2, 2);

            const T b03 = b(0);
            const T b13 = b(1);
            const T b23 = b(2);

            result(0) = a00 * b03 + a01 * b13 + a02 * b23;
            result(1) = a10 * b03 + a11 * b13 + a12 * b23;
            result(2) = a20 * b03 + a21 * b13 + a22 * b23;
        }


        static
        inline const Rotation3D<T> multiply(const Rotation3D<T>& a, const Rotation3D<T>& b)
        {
            const T a00 = a(0, 0);
            const T a01 = a(0, 1);
            const T a02 = a(0, 2);

            const T a10 = a(1, 0);
            const T a11 = a(1, 1);
            const T a12 = a(1, 2);

            const T a20 = a(2, 0);
            const T a21 = a(2, 1);
            const T a22 = a(2, 2);

            const T b00 = b(0, 0);
            const T b01 = b(0, 1);
            const T b02 = b(0, 2);

            const T b10 = b(1, 0);
            const T b11 = b(1, 1);
            const T b12 = b(1, 2);

            const T b20 = b(2, 0);
            const T b21 = b(2, 1);
            const T b22 = b(2, 2);

            return Rotation3D<T>(
                a00 * b00 +
                a01 * b10 +
                a02 * b20,

                a00 * b01 +
                a01 * b11 +
                a02 * b21,

                a00 * b02 +
                a01 * b12 +
                a02 * b22,

                a10 * b00 +
                a11 * b10 +
                a12 * b20,

                a10 * b01 +
                a11 * b11 +
                a12 * b21,

                a10 * b02 +
                a11 * b12 +
                a12 * b22,

                a20 * b00 +
                a21 * b10 +
                a22 * b20,

                a20 * b01 +
                a21 * b11 +
                a22 * b21,

                a20 * b02 +
                a21 * b12 +
                a22 * b22);
        }

        static inline const Vector3D<T> multiply(const Rotation3D<T>& a,
                                                 const Vector3D<T>& b)
        {
            const T a00 = a(0, 0);
            const T a01 = a(0, 1);
            const T a02 = a(0, 2);

            const T a10 = a(1, 0);
            const T a11 = a(1, 1);
            const T a12 = a(1, 2);

            const T a20 = a(2, 0);
            const T a21 = a(2, 1);
            const T a22 = a(2, 2);

            const T b03 = b(0);
            const T b13 = b(1);
            const T b23 = b(2);

            return Vector3D<T> (a00 * b03 + a01 * b13 + a02 * b23, a10
                    * b03 + a11 * b13 + a12 * b23, a20 * b03 + a21 * b13
                    + a22 * b23);
       }



    private:
        Base _matrix;
    };
# 525 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
    template<class Q, class T>
    const Rotation3D<Q> cast(const Rotation3D<T>& rot)
    {
        Rotation3D<Q> res(Rotation3D<Q>::identity());
        for (size_t i = 0; i < 3; i++)
            for (size_t j = 0; j < 3; j++)
                res(i, j) = static_cast<Q>(rot(i, j));
        return res;
    }
# 549 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
    template <class T>
    const Rotation3D<T> inverse(const Rotation3D<T>& aRb)
    {
        return Rotation3D<T>(trans(aRb.m()));
    }
# 564 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp"
    template <class T>
    std::ostream& operator<<(std::ostream &os, const Rotation3D<T>& r)
    {
        return os
            << "Rotation3D {"
            << r(0, 0) << ", " << r(0, 1) << ", " << r(0, 2) << ", "
            << r(1, 0) << ", " << r(1, 1) << ", " << r(1, 2) << ", "
            << r(2, 0) << ", " << r(2, 1) << ", " << r(2, 2)
            << "}";
    }




}}
# 28 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3DVector.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3DVector.hpp"
#define RW_MATH_ROTATION3DVECTOR_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3DVector.hpp"
namespace rw { namespace math {
# 40 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3DVector.hpp"
    template<class T = double>
    class Rotation3DVector{
    public:



        virtual ~Rotation3DVector(){}





        virtual const Rotation3D<T> toRotation3D() const = 0;

    protected:





        Rotation3DVector(const Rotation3DVector&) {}





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

    protected:



        Rotation3DVector() {}
    };


}}
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 1 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3
       
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 2 3
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 2

namespace rw { namespace math {
# 51 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
    template<class T = double>
    class Transform3D
    {
    public:





        Transform3D() :
            _d(),
            _R(Rotation3D<T>::identity())
        {}






        Transform3D(const Vector3D<T>& d, const Rotation3D<T>& R) :
            _d(d),
            _R(R)
        {}





        explicit Transform3D(const Rotation3D<T>& R) :
            _d(0, 0, 0),
            _R(R)
        {}





        explicit Transform3D(const Vector3D<T>& d) :
            _d(d),
            _R(Rotation3D<T>::identity())
        {}
# 102 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        Transform3D(const Vector3D<T>& d, const Rotation3DVector<T>& r) :
            _d(d),
            _R(r.toRotation3D())
        {}
# 129 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        static const Transform3D DH(T alpha, T a, T d, T theta);
# 157 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        static const Transform3D craigDH(T alpha, T a, T d, T theta);
# 178 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        static const Transform3D& identity()
        {
            static const Transform3D id(
                Vector3D<T>(0, 0, 0),
                Rotation3D<T>::identity());
            return id;
        }
# 194 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        T& operator()(std::size_t row, std::size_t col)
        {
            ((row < 3) ? static_cast<void> (0) : __assert_fail ("row < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp", 196, __PRETTY_FUNCTION__));
            ((col < 4) ? static_cast<void> (0) : __assert_fail ("col < 4", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp", 197, __PRETTY_FUNCTION__));
            if(row < 3 && col < 3)
                return _R( row, col);
            else
                return _d( row );
        }







        const T& operator()(std::size_t row, std::size_t col) const {
            ((row < 3) ? static_cast<void> (0) : __assert_fail ("row < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp", 211, __PRETTY_FUNCTION__));
            ((col < 4) ? static_cast<void> (0) : __assert_fail ("col < 4", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp", 212, __PRETTY_FUNCTION__));
            if(row < 3 && col < 3)
                return _R( row, col);
            else
                return _d( row );
        }
# 229 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        bool operator==(const Transform3D<> &rhs) const {
            return (R() == rhs.R());
        }
# 249 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
        friend const Transform3D operator*(const Transform3D& aTb, const Transform3D& bTc)
        {
            return Transform3D(aTb._d + aTb._R * bTc._d, aTb._R * bTc._R);
        }







        friend const Vector3D<T> operator*(const Transform3D& aTb, const Vector3D<T>& bP)
        {
            return aTb._R * bP + aTb._d ;
        }





        Rotation3D<T>& R() { return _R; }





        const Rotation3D<T>& R() const { return _R; }





        Vector3D<T>& P() { return _d; }





        const Vector3D<T>& P() const { return _d; }







        friend std::ostream& operator<<(std::ostream &os, const Transform3D<T>& t)
        {

            return os
                << "Transform3D("
                << t.P()
                << ", "
                << t.R()
                << ")";
        }






        template<class Q>
        friend const Transform3D<Q> cast(const Transform3D<T>& trans)
        {
            Transform3D<Q> res;
            for (size_t i = 0; i<3; i++)
                for (size_t j = 0; j<4; j++)
                    res(i,j) = static_cast<Q>(trans(i,j));
            return res;
        }




        static inline void multiply(const Transform3D<T>& a,
                                    const Transform3D<T>& b,
                                    Transform3D<T>& result)
        {
            Rotation3D<T>::multiply(a.R(), b.R(), result.R());
            Rotation3D<T>::multiply(a.R(), b.P(), result.P());
            result.P() += a.P();
        }

    private:
        Vector3D<T> _d;
        Rotation3D<T> _R;
    };
# 360 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp"
    template <class T>
    const Transform3D<T> inverse(const Transform3D<T>& aTb)
    {
        return Transform3D<T>(
            -(inverse(aTb.R()) * aTb.P()),
            inverse(aTb.R()));
    }



}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp"
#define RW_COMMON_PROPERTYBASE_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp"
#define RW_COMMON_PROPERTYTYPE_HPP 







# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector3D.hpp" 1
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
#define RW_MATH_VECTOR2D_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Constants.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Constants.hpp"
#define RW_MATH_CONSTANTS_HPP 





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Constants.hpp" 2

namespace rw { namespace math {





 const double Pi = 3.1415926535897932384626433832795;


    const double Inch2Meter = 0.0254;


    const double Meter2Inch = 1 / Inch2Meter;


    const double Deg2Rad = Pi / 180;


    const double Rad2Deg = 180 / Pi;


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp" 2

namespace rw { namespace math {
# 59 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
    template<class T = double>
    class Vector2D
    {
        typedef boost::numeric::ublas::bounded_vector<T, 2> Base;

    public:

        typedef T value_type;




        Vector2D()
        {
         m()[0] = 0;
         m()[1] = 0;
        }
# 84 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        Vector2D(T x, T y)
        {
         m()[0] = x;
         m()[1] = y;
        }





        template <class R>
        Vector2D(const boost::numeric::ublas::vector_expression<R>& r) :
            _vec(r)
        {}




        const Base& m() const { return _vec; }




        Base& m() { return _vec; }







        size_t size() const { return 2; }
# 127 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        const T& operator()(size_t i) const
        {
            return m()[i];
        }
# 139 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        T& operator()(size_t i)
        {
            return m()[i];
        }






        const T& operator[](size_t i) const { return m()(i); }






        T& operator[](size_t i) { return m()(i); }




        friend const Vector2D<T> operator/(const Vector2D<T>& v, T s)
        {
            return Vector2D<T>(v.m() / s);
        }




        friend const Vector2D<T> operator*(const Vector2D<T>& v, T s)
        {
            return Vector2D<T>(v.m() * s);
        }




        friend const Vector2D<T> operator*(T s, const Vector2D<T>& v)
        {
            return Vector2D<T>(s * v.m());
        }




        friend const Vector2D<T> operator-(const Vector2D<T>& a, const Vector2D<T>& b)
        {
            return Vector2D<T>(a.m() - b.m());
        }




        friend const Vector2D<T> operator+(const Vector2D<T>& a, const Vector2D<T>& b)
        {
            return Vector2D<T>(a.m() + b.m());
        }




        Vector2D<T>& operator*=(T s)
        {
            m() *= s;
            return *this;
        }




        Vector2D<T>& operator/=(T s)
        {
            m() /= s;
            return *this;
        }




        Vector2D<T>& operator+=(const Vector2D<T>& v)
        {
            m() += v.m();
            return *this;
        }




        Vector2D<T>& operator-=(const Vector2D<T>& v)
        {
            m() -= v.m();
            return *this;
        }




        const Vector2D<T> operator-() const
        {
            return Vector2D<T>(-m());
        }
# 257 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        friend T cross(const Vector2D<T>& v1, const Vector2D<T>& v2)
        {
            return v1(0) * v2(1) - v1(1) * v2(0);
        }
# 269 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        friend double dot(const Vector2D<T>& v1, const Vector2D<T>& v2)
        {
            return inner_prod(v1.m(), v2.m());
        }






        double angle()
        {
            return atan2(m()[1],m()[0]);
        }





        friend double angle(const Vector2D<T>& v1, const Vector2D<T>& v2)
        {
            return atan2(v2(1),v2(0)) - atan2(v1(1),v1(0));
        }
# 303 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        friend const Vector2D<T> normalize(const Vector2D<T>& v)
        {
            T length = v.norm2();
            if (length != 0)
                return Vector2D<T>(v(0)/length, v(1)/length);
            else
                return Vector2D<T>(0,0);
        }
# 319 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
        template<class Q>
        friend const Vector2D<Q> cast(const Vector2D<T>& v)
        {
            return Vector2D<Q>(
                static_cast<Q>(v(0)),
                static_cast<Q>(v(1)));
        }




        friend std::ostream& operator<<(std::ostream& out, const Vector2D<T>& v)
        {
            return out
                << "Vector2D {"
                << v[0] << ", " << v[1]
                << "}";
        }





        T norm2() const { return norm_2(m()); }





        T norm1() const { return norm_1(m()); }





        T normInf() const { return norm_inf(m()); }

    private:

     Base _vec;
    };
# 370 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp"
    template <class T>
    bool operator==(const Vector2D<T>& a, const Vector2D<T>& b)
    { return a[0] == b[0] && a[1] == b[1]; }


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
#define RW_MATH_Q_HPP 
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
namespace rw { namespace math {




    class Q
    {
    public:

        typedef boost::numeric::ublas::vector<double> Base;


        typedef boost::numeric::ublas::zero_vector<double> ZeroBase;


        typedef Base::const_iterator const_iterator;


        typedef Base::iterator iterator;


        typedef Base::value_type value_type;


        typedef Base::reference reference;


        typedef Base::pointer pointer;


        typedef Base::const_pointer const_pointer;


        typedef Base::difference_type difference_type;




        explicit Q(size_t dim) : _vec(dim) {}






        Q() : _vec(0) {}
# 86 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
        Q(size_t n, const double* values);







        Q(size_t n, double value);




        static Q zero(int n)
        {
            return Q(ZeroBase(n));
        }




        size_t size() const { return m().size(); }




        bool empty() const { return size() == 0; }







        template <class R>
        explicit Q(const boost::numeric::ublas::vector_expression<R>& r) :
            _vec(r)
        {}




        const Base& m() const { return _vec; }




        Base& m() { return _vec; }




        const_iterator begin() const { return m().begin(); }




        const_iterator end() const { return m().end(); }




        iterator begin() { return m().begin(); }




        iterator end() { return m().end(); }







        const Q getSubPart(size_t start, size_t cnt) const {
            ((start+cnt <= size()) ? (void)0 : rw::common::IOUtil::rwAssert("start+cnt <= size()", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp", 162));

            Q res(cnt);
            for (size_t i = 0; i<cnt; i++) {
                res(i) = (*this)[start+i];
            }
            return res;
        }

        void setSubPart(size_t index, const Q& part) {
            ((index + part.size() <= size()) ? (void)0 : rw::common::IOUtil::rwAssert("index + part.size() <= size()", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp", 172));
            for (size_t i = 0; i<part.size(); i++) {
                (*this)[index+i] = part(i);
            }
        }
# 185 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
        double norm2() const {
            return norm_2(m());
        }





        double norm1() const {
            return norm_1(m());
        }





        double normInf() const {
            return norm_inf(m());
        }
# 213 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
        const double& operator()(size_t i) const { return m()(i); }






        double& operator()(size_t i) { return m()(i); }






        const double& operator[](size_t i) const { return m()(i); }






        double& operator[](size_t i) { return m()(i); }




        friend const Q operator/(const Q& v, double s)
        {
            return Q(v.m() / s);
        }




        friend const Q operator*(const Q& v, double s)
        {
            return Q(v.m() * s);
        }




        friend const Q operator*(double s, const Q& v)
        {
            return Q(s * v.m());
        }




        friend const Q operator-(const Q& a, const Q& b)
        {
            return Q(a.m() - b.m());
        }




        friend const Q operator+(const Q& a, const Q& b)
        {
            return Q(a.m() + b.m());
        }




        Q& operator*=(double s)
        {
            m() *= s;
            return *this;
        }




        Q& operator/=(double s)
        {
            m() /= s;
            return *this;
        }




        Q& operator+=(const Q& v)
        {
            m() += v.m();
            return *this;
        }




        Q& operator-=(const Q& v)
        {
            m() -= v.m();
            return *this;
        }




        const Q operator-() const
        {
            return Q(-m());
        }


    private:
        Base _vec;
    };
# 341 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
    bool operator==(const Q& q1, const Q& q2);






    inline bool operator!=(const Q& q1, const Q& q2) { return !(q1 == q2); }






    std::ostream& operator<<(std::ostream& out, const Q& v);
# 367 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
    std::istream& operator>>(std::istream& in, Q& q);






    double dot(const Q& a, const Q& b);
# 384 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp"
    rw::math::Q concat(const Q& q1, const Q& q2);


}}
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation3D.hpp" 1
# 33 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
#define RW_MATH_RPY_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
namespace rw { namespace math {







    template<class T = double>
    class RPY: public Rotation3DVector<T> {
    public:




        RPY() : _rpy(0.0, 0.0, 0.0) {}







        RPY(T roll, T pitch, T yaw) : _rpy(roll, pitch, yaw) {}
# 69 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
        explicit RPY(const Rotation3D<T>& R, T epsilon = 1e-5);




        const Rotation3D<T> toRotation3D() const;
# 83 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
        T& operator()(size_t index){
            return _rpy(index);
        }
# 94 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
        const T& operator()(size_t index) const {
            return _rpy(index);
        }
# 107 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
        friend std::ostream& operator<<(std::ostream& os, const RPY<T>& rpy){
            return os <<" RPY { "<<rpy(0)<<", "<<rpy(1)<<", "<<rpy(2)<<"}";

        }
# 119 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/RPY.hpp"
        template<class Q>
        friend const RPY<Q> cast(const RPY<T>& rpy) {
            return RPY<Q>(
                static_cast<Q>(rpy(0)),
                static_cast<Q>(rpy(1)),
                static_cast<Q>(rpy(2)));
        }

    private:
        Vector3D<T> _rpy;
    };


}}
# 34 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
#define RW_MATH_EAA_HPP 
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
namespace rw { namespace math {
# 52 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
    template<class T = double>
    class EAA : public Rotation3DVector<T>
    {
    public:
# 102 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
        explicit EAA(const Rotation3D<T>& R);




        EAA():
            _eaa(0,0,0)
        {}







        EAA(const Vector3D<T>& axis, T angle) :
            _eaa(axis * angle)
        {}
# 134 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
        EAA(T thetakx, T thetaky, T thetakz) :
            _eaa(Vector3D<T>(thetakx, thetaky, thetakz)){}







        EAA(const Vector3D<T>& v1, const Vector3D<T>& v2) :
            _eaa(0,0,0)
        {
         const T epsilon = (T)0.00001;
         T dval = dot(v1,v2);
         if(fabs(dval)<epsilon){


          if(dval<epsilon){
           _eaa = Vector3D<T>(v1(2)*(T)Pi,v1(0)*(T)Pi,v1(1)*(T)Pi);
          }
         } else {
          T cosangle = acos( dval );
          _eaa = normalize( cross(v1,v2) )*cosangle;
         }
        }







        explicit EAA(Vector3D<T> eaa) : _eaa(eaa) {}
# 187 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
        virtual const Rotation3D<T> toRotation3D() const;





        T angle() const
        {
            return norm_2(_eaa.m());
        }





        const Vector3D<T> axis() const
        {
            T theta = angle();
            if (theta < 1e-6)
                return Vector3D<T>(0, 0, 0);
            else
                return _eaa / theta;
        }






        const T& operator[](size_t i) const{
            ((i < 3) ? static_cast<void> (0) : __assert_fail ("i < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp", 217, __PRETTY_FUNCTION__));
            return _eaa[i];
        }






        T& operator[](size_t i) {
            ((i < 3) ? static_cast<void> (0) : __assert_fail ("i < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp", 227, __PRETTY_FUNCTION__));
            return _eaa[i];
        }







        const T& operator()(size_t i) const{
            ((i < 3) ? static_cast<void> (0) : __assert_fail ("i < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp", 238, __PRETTY_FUNCTION__));
            return _eaa[i];
        }






        T& operator()(size_t i) {
            ((i < 3) ? static_cast<void> (0) : __assert_fail ("i < 3", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp", 248, __PRETTY_FUNCTION__));
            return _eaa[i];
        }
# 260 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp"
        friend const EAA operator*(const Rotation3D<T>& aRb, const EAA& bTKc)
        {
            return EAA(aRb * bTKc._eaa);

        }







        friend std::ostream& operator<<(std::ostream& os, const EAA<T>& eaa){
            return os <<" EAA { "<<eaa(0)<<", "<<eaa(1)<<", "<<eaa(2)<<"}";

        }







        friend const Vector3D<T> cross(const Vector3D<T>& v, const EAA<T>& eaa)
        {
            return cross(v, eaa._eaa);
        }






        template<class Q>
        friend const EAA<Q> cast(const EAA<T>& eaa) {
            return EAA<Q>(
                static_cast<Q>(eaa(0)),
                static_cast<Q>(eaa(1)),
                static_cast<Q>(eaa(2)));
        }

    private:
        Vector3D<T> _eaa;
    };



}}
# 35 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
#define RW_MATH_QUATERNION_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
# 1 "/usr/include/boost-1_41/boost/math/quaternion.hpp" 1
# 11 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_HPP 
# 21 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/locale" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/locale" 3
#define _GLIBCXX_LOCALE 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/locale" 3




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
#define _LOCALE_FACETS_NONIO_H 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ctime" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ctime" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ctime" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/ctime" 2 3



#define _GLIBCXX_CTIME 1


#undef clock
#undef difftime
#undef mktime
#undef time
#undef asctime
#undef ctime
#undef gmtime
#undef localtime
#undef strftime

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

  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;

}
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 2 3

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







  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(__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);
# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const;

      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/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 3
namespace std __attribute__ ((__visibility__ ("default"))) {

  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)
    {
      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
 {
   const size_t __len = __builtin_strlen(__s) + 1;
   char* __tmp = new char[__len];
   __builtin_memcpy(__tmp, __s, __len);
   _M_name_timepunct = __tmp;
 }
      else
 _M_name_timepunct = _S_get_c_name();

      try
 { _M_initialize_timepunct(__cloc); }
      catch(...)
 {
   if (_M_name_timepunct != _S_get_c_name())
     delete [] _M_name_timepunct;
   throw;
 }
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {
      if (_M_name_timepunct != _S_get_c_name())
 delete [] _M_name_timepunct;
      delete _M_data;
      _S_destroy_c_locale(_M_c_locale_timepunct);
    }

}
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 360 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;

      typedef basic_string<_CharT> __string_type;


      static locale::id id;
# 382 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 448 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 505 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }

    protected:

      virtual
      ~time_get() { }
# 551 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 588 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 607 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 626 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;


      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;



      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_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() { }
    };
# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 722 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 761 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:

      virtual
      ~time_put()
      { }
# 788 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;


  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { };

    protected:
      virtual
      ~time_put_byname() { }
    };
# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    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;
# 947 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(); }
# 959 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 974 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(__cloc, __s); }
# 988 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1001 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1030 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1060 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1077 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1093 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 1150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1188 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1201 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1214 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1242 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1256 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = __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 (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;


# 1350 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1402 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1432 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 1455 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 1467 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 1478 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 1499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:


      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1520 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 1562 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 1596 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 1619 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 1630 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;






  struct messages_base
  {
    typedef int catalog;
  };
# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 1697 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1711 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1724 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1742 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 1771 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1791 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {
# 1867 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.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/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 3
# 1 "/usr/include/libintl.h" 1 3 4
# 22 "/usr/include/libintl.h" 3 4
#define _LIBINTL_H 1





#define __USE_GNU_GETTEXT 1



#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 1 : -1)


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
}
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3

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


  template<typename _CharT>
     messages<_CharT>::messages(size_t __refs)
     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
       _M_name_messages(_S_get_c_name())
     { }

  template<typename _CharT>
     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
    size_t __refs)
     : facet(__refs), _M_c_locale_messages(__null), _M_name_messages(__null)
     {
       if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
  {
    const size_t __len = __builtin_strlen(__s) + 1;
    char* __tmp = new char[__len];
    __builtin_memcpy(__tmp, __s, __len);
    _M_name_messages = __tmp;
  }
       else
  _M_name_messages = _S_get_c_name();


       _M_c_locale_messages = _S_clone_c_locale(__cloc);
     }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
      const char* __dir) const
    {
      bindtextdomain(__s.c_str(), __dir);
      return this->do_open(__s, __loc);
    }


  template<typename _CharT>
    messages<_CharT>::~messages()
    {
      if (_M_name_messages != _S_get_c_name())
 delete [] _M_name_messages;
      _S_destroy_c_locale(_M_c_locale_messages);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::do_open(const basic_string<char>& __s,
         const locale&) const
    {


      textdomain(__s.c_str());
      return 0;
    }

  template<typename _CharT>
    void
    messages<_CharT>::do_close(catalog) const
    { }


   template<typename _CharT>
     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
     : messages<_CharT>(__refs)
     {
       if (this->_M_name_messages != locale::facet::_S_get_c_name())
  {
    delete [] this->_M_name_messages;
    if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
      {
        const size_t __len = __builtin_strlen(__s) + 1;
        char* __tmp = new char[__len];
        __builtin_memcpy(__tmp, __s, __len);
        this->_M_name_messages = __tmp;
      }
    else
      this->_M_name_messages = locale::facet::_S_get_c_name();
  }

       if (__builtin_strcmp(__s, "C") != 0
    && __builtin_strcmp(__s, "POSIX") != 0)
  {
    this->_S_destroy_c_locale(this->_M_c_locale_messages);
    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
  }
     }

}
# 1906 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/codecvt.h" 1 3
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/codecvt.h" 3
#define _CODECVT_H 1

       
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/codecvt.h" 3

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


  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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;
# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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);
      }
# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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() { }
# 235 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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 (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }

    protected:
      virtual
      ~codecvt_byname() { }
    };





  extern template class codecvt_byname<char, char, mbstate_t>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);


  extern template class codecvt_byname<wchar_t, char, mbstate_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);



}
# 1909 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 1 3
# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 3
#define _LOCALE_FACETS_NONIO_TCC 1

       
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 3

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

  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = __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, 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>(_M_grouping[0]) > 0
    && (_M_grouping[0]
        != __gnu_cxx::__numeric_traits<char>::__max));

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



  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || (__mandatory_sign
      && (static_cast<part>(__p.field[3])
          == money_base::sign)))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, ++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   if (__lc->_M_frac_digits <= 0)
     break;

   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;
       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, ++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __digits) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   __digits.resize(__len);
   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
 }
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     long __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
         {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
    if (__lc->_M_grouping_size)
      {
      __value.assign(2 * __paddec, char_type());
       _CharT* __vend =
        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.erase(__vend - &__value[0]);
      }
    else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
         }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 550 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);
 }
# 582 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.tcc" 3
      string_type __digits(__len, char_type());
      __ctype.widen(__cs, __cs + __len, &__digits[0]);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }






  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      ios_base::iostate __tmperr = ios_base::goodbit;
      for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':

    const char_type* __days1[7];
    __tp._M_days_abbreviated(__days1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
       7, __io, __tmperr);
    break;
  case 'A':

    const char_type* __days2[7];
    __tp._M_days(__days2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
       7, __io, __tmperr);
    break;
  case 'h':
  case 'b':

    const char_type* __months1[12];
    __tp._M_months_abbreviated(__months1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months1, 12, __io, __tmperr);
    break;
  case 'B':

    const char_type* __months2[12];
    __tp._M_months(__months2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months2, 12, __io, __tmperr);
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dt[0]);
    break;
  case 'd':

    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
      __io, __tmperr);
    break;
  case 'e':


    if (__ctype.is(ctype_base::space, *__beg))
      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
        1, __io, __tmperr);
    else
      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
        2, __io, __tmperr);
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
      __io, __tmperr);
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
      __io, __tmperr);
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mon = __mem - 1;
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
      __io, __tmperr);
    break;
  case 'n':
    if (__ctype.narrow(*__beg, 0) == '\n')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,



      __io, __tmperr);
    break;
  case 't':
    if (__ctype.narrow(*__beg, 0) == '\t')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dates[0]);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __times[0]);
    break;
  case 'y':
  case 'C':

    __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
      __io, __tmperr);
    break;
  case 'Y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __tmperr);
    if (!__tmperr)
      __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, __tmperr);


        if (__beg != __end && !__tmperr && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __tmperr);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __tmperr);
   }
      }
    else
      __tmperr |= ios_base::failbit;
    break;
  default:

    __tmperr |= ios_base::failbit;
  }
     }
   else
     {

       if (__format[__i] == *__beg)
  ++__beg;
       else
  __tmperr |= ios_base::failbit;
     }
 }

      if (__tmperr)
 __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;
      ios_base::iostate __tmperr = ios_base::goodbit;
      __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7,
         __io, __tmperr);







      if (!__tmperr && __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)
  __tmperr |= ios_base::failbit;
     }
 }
      if (!__tmperr)
 __tm->tm_wday = __tmpwday;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __months[12];
      __tp._M_months_abbreviated(__months);
      int __tmpmon;
      ios_base::iostate __tmperr = ios_base::goodbit;
      __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
         __io, __tmperr);







      if (!__tmperr && __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)
  __tmperr |= ios_base::failbit;
     }
 }
      if (!__tmperr)
 __tm->tm_mon = __tmpmon;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

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






  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class money_get<char>;
  extern template class money_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class money_get<wchar_t>;
  extern template class money_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);



}
# 1912 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/locale_facets_nonio.h" 2 3
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/locale" 2 3
# 22 "/usr/include/boost-1_41/boost/math/quaternion.hpp" 2


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
#define _GLIBCXX_VALARRAY 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cmath" 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3




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

  template<class _Clos, typename _Tp>
    class _Expr;

  template<typename _Tp1, typename _Tp2>
    class _ValArray;

  template<class _Oper, template<class, class> class _Meta, class _Dom>
    struct _UnClos;

  template<class _Oper,
        template<class, class> class _Meta1,
        template<class, class> class _Meta2,
        class _Dom1, class _Dom2>
    class _BinClos;

  template<template<class, class> class _Meta, class _Dom>
    class _SClos;

  template<template<class, class> class _Meta, class _Dom>
    class _GClos;

  template<template<class, class> class _Meta, class _Dom>
    class _IClos;

  template<template<class, class> class _Meta, class _Dom>
    class _ValFunClos;

  template<template<class, class> class _Meta, class _Dom>
    class _RefFunClos;

  template<class _Tp> class valarray;
  class slice;
  template<class _Tp> class slice_array;
  class gslice;
  template<class _Tp> class gslice_array;
  template<class _Tp> class mask_array;
  template<class _Tp> class indirect_array;

}

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 1 3
# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 3
#define _VALARRAY_ARRAY_H 1

       
# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 3



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstdlib" 2 3
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 2 3


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






  inline void*
  __valarray_get_memory(size_t __n)
  { return operator new(__n); }

  template<typename _Tp>
    inline _Tp*__restrict__
    __valarray_get_storage(size_t __n)
    {
      return static_cast<_Tp*__restrict__>
 (std::__valarray_get_memory(__n * sizeof(_Tp)));
    }


  inline void
  __valarray_release_memory(void* __p)
  { operator delete(__p); }



  template<typename _Tp, bool>
    struct _Array_default_ctor
    {


      inline static void
      _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
      {
 while (__b != __e)
   new(__b++) _Tp();
      }
    };

  template<typename _Tp>
    struct _Array_default_ctor<_Tp, true>
    {

      inline static void
      _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
      { __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp)); }
    };

  template<typename _Tp>
    inline void
    __valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
    {
      _Array_default_ctor<_Tp, __is_scalar<_Tp>::__value>::_S_do_it(__b, __e);
    }




  template<typename _Tp, bool>
    struct _Array_init_ctor
    {


      inline static void
      _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
      {
 while (__b != __e)
   new(__b++) _Tp(__t);
      }
    };

  template<typename _Tp>
    struct _Array_init_ctor<_Tp, true>
    {
      inline static void
      _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
      {
 while (__b != __e)
   *__b++ = __t;
      }
    };

  template<typename _Tp>
    inline void
    __valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e,
         const _Tp __t)
    {
      _Array_init_ctor<_Tp, __is_pod(_Tp)>::_S_do_it(__b, __e, __t);
    }





  template<typename _Tp, bool>
    struct _Array_copy_ctor
    {


      inline static void
      _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
        _Tp* __restrict__ __o)
      {
 while (__b != __e)
   new(__o++) _Tp(*__b++);
      }
    };

  template<typename _Tp>
    struct _Array_copy_ctor<_Tp, true>
    {
      inline static void
      _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
        _Tp* __restrict__ __o)
      { __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); }
    };

  template<typename _Tp>
    inline void
    __valarray_copy_construct(const _Tp* __restrict__ __b,
         const _Tp* __restrict__ __e,
         _Tp* __restrict__ __o)
    {
      _Array_copy_ctor<_Tp, __is_pod(_Tp)>::_S_do_it(__b, __e, __o);
    }


  template<typename _Tp>
    inline void
    __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
          size_t __s, _Tp* __restrict__ __o)
    {
      if (__is_pod(_Tp))
 while (__n--)
   {
     *__o++ = *__a;
     __a += __s;
   }
      else
 while (__n--)
   {
     new(__o++) _Tp(*__a);
     __a += __s;
   }
    }


  template<typename _Tp>
    inline void
    __valarray_copy_construct (const _Tp* __restrict__ __a,
          const size_t* __restrict__ __i,
          _Tp* __restrict__ __o, size_t __n)
    {
      if (__is_pod(_Tp))
 while (__n--)
   *__o++ = __a[*__i++];
      else
 while (__n--)
   new (__o++) _Tp(__a[*__i++]);
    }


  template<typename _Tp>
    inline void
    __valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
    {
      if (!__is_pod(_Tp))
 while (__b != __e)
   {
     __b->~_Tp();
     ++__b;
   }
    }


  template<typename _Tp>
    inline void
    __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
    {
      while (__n--)
 *__a++ = __t;
    }


  template<typename _Tp>
    inline void
    __valarray_fill(_Tp* __restrict__ __a, size_t __n,
      size_t __s, const _Tp& __t)
    {
      for (size_t __i = 0; __i < __n; ++__i, __a += __s)
 *__a = __t;
    }


  template<typename _Tp>
    inline void
    __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
      size_t __n, const _Tp& __t)
    {
      for (size_t __j = 0; __j < __n; ++__j, ++__i)
 __a[*__i] = __t;
    }



  template<typename _Tp, bool>
    struct _Array_copier
    {
      inline static void
      _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
      {
 while(__n--)
   *__b++ = *__a++;
      }
    };

  template<typename _Tp>
    struct _Array_copier<_Tp, true>
    {
      inline static void
      _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
      { __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); }
    };


  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
      _Tp* __restrict__ __b)
    {
      _Array_copier<_Tp, __is_pod(_Tp)>::_S_do_it(__a, __n, __b);
    }


  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
      _Tp* __restrict__ __b)
    {
      for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s)
 *__b = *__a;
    }


  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
      size_t __n, size_t __s)
    {
      for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s)
 *__b = *__a;
    }



  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
      _Tp* __restrict__ __dst, size_t __s2)
    {
      for (size_t __i = 0; __i < __n; ++__i)
 __dst[__i * __s2] = __src[__i * __s1];
    }


  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __a,
      const size_t* __restrict__ __i,
      _Tp* __restrict__ __b, size_t __n)
    {
      for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i)
 *__b = __a[*__i];
    }


  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
      _Tp* __restrict__ __b, const size_t* __restrict__ __i)
    {
      for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i)
 __b[*__i] = *__a;
    }



  template<typename _Tp>
    inline void
    __valarray_copy(const _Tp* __restrict__ __src, size_t __n,
      const size_t* __restrict__ __i,
      _Tp* __restrict__ __dst, const size_t* __restrict__ __j)
    {
      for (size_t __k = 0; __k < __n; ++__k)
 __dst[*__j++] = __src[*__i++];
    }
# 348 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 3
  template<typename _Tp>
    inline _Tp
    __valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l)
    {
      _Tp __r = _Tp();
      while (__f != __l)
 __r += *__f++;
      return __r;
    }


  template<typename _Tp>
    inline _Tp
    __valarray_product(const _Tp* __restrict__ __f,
         const _Tp* __restrict__ __l)
    {
      _Tp __r = _Tp(1);
      while (__f != __l)
 __r = __r * *__f++;
      return __r;
    }


  template<typename _Ta>
    inline typename _Ta::value_type
    __valarray_min(const _Ta& __a)
    {
      size_t __s = __a.size();
      typedef typename _Ta::value_type _Value_type;
      _Value_type __r = __s == 0 ? _Value_type() : __a[0];
      for (size_t __i = 1; __i < __s; ++__i)
 {
   _Value_type __t = __a[__i];
   if (__t < __r)
     __r = __t;
 }
      return __r;
    }

  template<typename _Ta>
    inline typename _Ta::value_type
    __valarray_max(const _Ta& __a)
    {
      size_t __s = __a.size();
      typedef typename _Ta::value_type _Value_type;
      _Value_type __r = __s == 0 ? _Value_type() : __a[0];
      for (size_t __i = 1; __i < __s; ++__i)
 {
   _Value_type __t = __a[__i];
   if (__t > __r)
     __r = __t;
 }
      return __r;
    }







  template<typename _Tp>
    struct _Array
    {
      explicit _Array(size_t);
      explicit _Array(_Tp* const __restrict__);
      explicit _Array(const valarray<_Tp>&);
      _Array(const _Tp* __restrict__, size_t);

      _Tp* begin() const;

      _Tp* const __restrict__ _M_data;
    };



  template<typename _Tp>
    inline void
    __valarray_copy_construct(_Array<_Tp> __a, _Array<size_t> __i,
         _Array<_Tp> __b, size_t __n)
    { std::__valarray_copy_construct(__a._M_data, __i._M_data,
         __b._M_data, __n); }


  template<typename _Tp>
    inline void
    __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s,
         _Array<_Tp> __b)
    { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); }

  template<typename _Tp>
    inline void
    __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
    { std::__valarray_fill(__a._M_data, __n, __t); }

  template<typename _Tp>
    inline void
    __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
    { std::__valarray_fill(__a._M_data, __n, __s, __t); }

  template<typename _Tp>
    inline void
    __valarray_fill(_Array<_Tp> __a, _Array<size_t> __i,
      size_t __n, const _Tp& __t)
    { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); }


  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
    { std::__valarray_copy(__a._M_data, __n, __b._M_data); }


  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
    { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }


  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
    { __valarray_copy(__a._M_data, __b._M_data, __n, __s); }



  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
                    _Array<_Tp> __b, size_t __s2)
    { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }


  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
      _Array<_Tp> __b, size_t __n)
    { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }


  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
      _Array<size_t> __i)
    { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }



  template<typename _Tp>
    inline void
    __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
                    _Array<_Tp> __dst, _Array<size_t> __j)
    {
      std::__valarray_copy(__src._M_data, __n, __i._M_data,
      __dst._M_data, __j._M_data);
    }

  template<typename _Tp>
    inline
    _Array<_Tp>::_Array(size_t __n)
    : _M_data(__valarray_get_storage<_Tp>(__n))
    { std::__valarray_default_construct(_M_data, _M_data + __n); }

  template<typename _Tp>
    inline
    _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
    : _M_data (__p) {}

  template<typename _Tp>
    inline
    _Array<_Tp>::_Array(const valarray<_Tp>& __v)
    : _M_data (__v._M_data) {}

  template<typename _Tp>
    inline
    _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s)
    : _M_data(__valarray_get_storage<_Tp>(__s))
    { std::__valarray_copy_construct(__b, __s, _M_data); }

  template<typename _Tp>
    inline _Tp*
    _Array<_Tp>::begin () const
    { return _M_data; }

#define _DEFINE_ARRAY_FUNCTION(_Op,_Name) template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p _Op ##= __t; } template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p _Op ##= *__q; } template<typename _Tp, class _Dom> void _Array_augmented_ ##_Name(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p _Op ##= __e[__i]; } template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p _Op ##= *__q; } template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p _Op ##= *__q; } template<typename _Tp, class _Dom> void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p _Op ##= __e[__i]; } template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] _Op ##= *__q; } template<typename _Tp> inline void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p _Op ##= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented_ ##_Name(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] _Op ##= __e[__k]; } template<typename _Tp> void _Array_augmented_ ##_Name(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p _Op ##= *__q; } } template<typename _Tp> void _Array_augmented_ ##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p _Op ##= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented_ ##_Name(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p _Op ##= __e[__i]; } }
# 680 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 3
   template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p += __t; } template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p += *__q; } template<typename _Tp, class _Dom> void _Array_augmented___plus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p += __e[__i]; } template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p += *__q; } template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p += *__q; } template<typename _Tp, class _Dom> void _Array_augmented___plus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p += __e[__i]; } template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] += *__q; } template<typename _Tp> inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p += __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___plus(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] += __e[__k]; } template<typename _Tp> void _Array_augmented___plus(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p += *__q; } } template<typename _Tp> void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p += *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___plus(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p += __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p -= __t; } template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p -= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___minus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p -= __e[__i]; } template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p -= *__q; } template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p -= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___minus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p -= __e[__i]; } template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] -= *__q; } template<typename _Tp> inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p -= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___minus(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] -= __e[__k]; } template<typename _Tp> void _Array_augmented___minus(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p -= *__q; } } template<typename _Tp> void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p -= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___minus(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p -= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p *= __t; } template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p *= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___multiplies(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p *= __e[__i]; } template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p *= *__q; } template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p *= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p *= __e[__i]; } template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] *= *__q; } template<typename _Tp> inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p *= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] *= __e[__k]; } template<typename _Tp> void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p *= *__q; } } template<typename _Tp> void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p *= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p *= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p /= __t; } template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p /= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___divides(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p /= __e[__i]; } template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p /= *__q; } template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p /= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___divides(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p /= __e[__i]; } template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] /= *__q; } template<typename _Tp> inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p /= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___divides(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] /= __e[__k]; } template<typename _Tp> void _Array_augmented___divides(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p /= *__q; } } template<typename _Tp> void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p /= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___divides(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p /= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p %= __t; } template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p %= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___modulus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p %= __e[__i]; } template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p %= *__q; } template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p %= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___modulus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p %= __e[__i]; } template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] %= *__q; } template<typename _Tp> inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p %= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___modulus(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] %= __e[__k]; } template<typename _Tp> void _Array_augmented___modulus(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p %= *__q; } } template<typename _Tp> void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p %= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___modulus(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p %= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p ^= __t; } template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p ^= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p ^= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p ^= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p ^= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p ^= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] ^= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p ^= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] ^= __e[__k]; } template<typename _Tp> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p ^= *__q; } } template<typename _Tp> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p ^= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p ^= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p |= __t; } template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p |= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_or(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p |= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p |= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p |= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p |= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] |= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p |= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] |= __e[__k]; } template<typename _Tp> void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p |= *__q; } } template<typename _Tp> void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p |= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p |= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p &= __t; } template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p &= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_and(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p &= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p &= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p &= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p &= __e[__i]; } template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] &= *__q; } template<typename _Tp> inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p &= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] &= __e[__k]; } template<typename _Tp> void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p &= *__q; } } template<typename _Tp> void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p &= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p &= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p <<= __t; } template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p <<= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___shift_left(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p <<= __e[__i]; } template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p <<= *__q; } template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p <<= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p <<= __e[__i]; } template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] <<= *__q; } template<typename _Tp> inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p <<= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] <<= __e[__k]; } template<typename _Tp> void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p <<= *__q; } } template<typename _Tp> void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p <<= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p <<= __e[__i]; } }
   template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p >>= __t; } template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p >>= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___shift_right(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p >>= __e[__i]; } template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p >>= *__q; } template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p >>= *__q; } template<typename _Tp, class _Dom> void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p >>= __e[__i]; } template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<size_t> __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] >>= *__q; } template<typename _Tp> inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<size_t> __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p >>= __b._M_data[*__j]; } template<typename _Tp, class _Dom> void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<size_t> __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] >>= __e[__k]; } template<typename _Tp> void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p >>= *__q; } } template<typename _Tp> void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p >>= *__q; } } template<typename _Tp, class _Dom> void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<bool> __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p >>= __e[__i]; } }

#undef _DEFINE_ARRAY_FUNCTION

}


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.tcc" 1 3
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.tcc" 3
#define _VALARRAY_ARRAY_TCC 1

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

  template<typename _Tp>
    void
    __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
      const _Tp& __t)
    {
      _Tp* __p = __a._M_data;
      bool* __ok (__m._M_data);
      for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
 {
   while (!*__ok)
   {
     ++__ok;
     ++__p;
   }
   *__p = __t;
 }
    }







  template<typename _Tp>
    void
    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
      size_t __n)
    {
      _Tp* __p (__a._M_data);
      bool* __ok (__m._M_data);
      for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
    ++__q, ++__ok, ++__p)
 {
   while (! *__ok)
     {
       ++__ok;
       ++__p;
     }
   *__q = *__p;
 }
    }







  template<typename _Tp>
    void
    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
      _Array<bool> __m)
    {
      _Tp* __q (__b._M_data);
      bool* __ok (__m._M_data);
      for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
    ++__p, ++__ok, ++__q)
 {
   while (! *__ok)
     {
       ++__ok;
       ++__q;
     }
   *__q = *__p;
 }
    }






  template<typename _Tp>
    void
    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
      _Array<_Tp> __b, _Array<bool> __k)
    {
      _Tp* __p (__a._M_data);
      _Tp* __q (__b._M_data);
      bool* __srcok (__m._M_data);
      bool* __dstok (__k._M_data);
      for (size_t __i = 0; __i < __n;
    ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
 {
   while (! *__srcok)
     {
       ++__srcok;
       ++__p;
     }
   while (! *__dstok)
     {
       ++__dstok;
       ++__q;
     }
   *__q = *__p;
 }
    }



  template<typename _Tp, class _Dom>
    void
    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
    {
      _Tp* __p (__a._M_data);
      for (size_t __i = 0; __i < __n; ++__i, ++__p)
 *__p = __e[__i];
    }



  template<typename _Tp, class _Dom>
    void
    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
       _Array<_Tp> __a, size_t __s)
    {
      _Tp* __p (__a._M_data);
      for (size_t __i = 0; __i < __n; ++__i, __p += __s)
 *__p = __e[__i];
    }



  template<typename _Tp, class _Dom>
    void
    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
      _Array<_Tp> __a, _Array<size_t> __i)
    {
      size_t* __j (__i._M_data);
      for (size_t __k = 0; __k < __n; ++__k, ++__j)
 __a._M_data[*__j] = __e[__k];
    }



  template<typename _Tp>
    void
    __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
      size_t __n,
      _Array<_Tp> __a, _Array<size_t> __i)
    {
      size_t* __g (__f._M_data);
      size_t* __j (__i._M_data);
      for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g)
 __a._M_data[*__j] = __e._M_data[*__g];
    }







  template<typename _Tp, class _Dom>
    void
    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
      _Array<_Tp> __a, _Array<bool> __m)
    {
      bool* __ok (__m._M_data);
      _Tp* __p (__a._M_data);
      for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
 {
   while (! *__ok)
     {
       ++__ok;
       ++__p;
     }
   *__p = __e[__i];
 }
    }


  template<typename _Tp, class _Dom>
    void
    __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
         _Array<_Tp> __a)
    {
      _Tp* __p (__a._M_data);
      for (size_t __i = 0; __i < __n; ++__i, ++__p)
 new (__p) _Tp(__e[__i]);
    }


  template<typename _Tp>
    void
    __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
         _Array<_Tp> __b, size_t __n)
    {
      _Tp* __p (__a._M_data);
      bool* __ok (__m._M_data);
      for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
 {
   while (! *__ok)
     {
       ++__ok;
       ++__p;
     }
   new (__q) _Tp(*__p);
 }
    }

}
# 697 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_array.h" 2 3
# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 3
#define _VALARRAY_BEFORE_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3
#define _SLICE_ARRAY_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3
  class slice
  {
  public:

    slice();
# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3
    slice(size_t, size_t, size_t);


    size_t start() const;

    size_t size() const;

    size_t stride() const;

  private:
    size_t _M_off;
    size_t _M_sz;
    size_t _M_st;
  };



  inline
  slice::slice()
  : _M_off(0), _M_sz(0), _M_st(0) {}

  inline
  slice::slice(size_t __o, size_t __d, size_t __s)
  : _M_off(__o), _M_sz(__d), _M_st(__s) {}

  inline size_t
  slice::start() const
  { return _M_off; }

  inline size_t
  slice::size() const
  { return _M_sz; }

  inline size_t
  slice::stride() const
  { return _M_st; }
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3
  template<typename _Tp>
    class slice_array
    {
    public:
      typedef _Tp value_type;





      slice_array(const slice_array&);



      slice_array& operator=(const slice_array&);


      void operator=(const valarray<_Tp>&) const;

      void operator*=(const valarray<_Tp>&) const;

      void operator/=(const valarray<_Tp>&) const;

      void operator%=(const valarray<_Tp>&) const;

      void operator+=(const valarray<_Tp>&) const;

      void operator-=(const valarray<_Tp>&) const;

      void operator^=(const valarray<_Tp>&) const;

      void operator&=(const valarray<_Tp>&) const;

      void operator|=(const valarray<_Tp>&) const;

      void operator<<=(const valarray<_Tp>&) const;

      void operator>>=(const valarray<_Tp>&) const;

      void operator=(const _Tp &) const;


      template<class _Dom>
        void operator=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator*=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator/=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator%=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator+=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator-=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator^=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator&=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator|=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator<<=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
 void operator>>=(const _Expr<_Dom, _Tp>&) const;

    private:
      friend class valarray<_Tp>;
      slice_array(_Array<_Tp>, const slice&);

      const size_t _M_sz;
      const size_t _M_stride;
      const _Array<_Tp> _M_array;


      slice_array();
    };

  template<typename _Tp>
    inline
    slice_array<_Tp>::slice_array(_Array<_Tp> __a, const slice& __s)
    : _M_sz(__s.size()), _M_stride(__s.stride()),
      _M_array(__a.begin() + __s.start()) {}

  template<typename _Tp>
    inline
    slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
    : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}




  template<typename _Tp>
    inline slice_array<_Tp>&
    slice_array<_Tp>::operator=(const slice_array<_Tp>& __a)
    {
      std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
      _M_array, _M_stride);
      return *this;
    }

  template<typename _Tp>
    inline void
    slice_array<_Tp>::operator=(const _Tp& __t) const
    { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); }

  template<typename _Tp>
    inline void
    slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); }

  template<typename _Tp>
  template<class _Dom>
    inline void
    slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
    { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); }

#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) template<typename _Tp> inline void slice_array<_Tp>::operator _Op ##=(const valarray<_Tp>& __v) const { _Array_augmented_ ##_Name(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator _Op ##=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented_ ##_Name(_M_array, _M_stride, __e, _M_sz); }
# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/slice_array.h" 3
template<typename _Tp> inline void slice_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator *=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator /=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___divides(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator %=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator +=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___plus(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator -=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___minus(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator ^=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator &=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator |=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator <<=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_stride, __e, _M_sz); }
template<typename _Tp> inline void slice_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template<typename _Tp> template<class _Dom> inline void slice_array<_Tp>::operator >>=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_stride, __e, _M_sz); }

#undef _DEFINE_VALARRAY_OPERATOR



}
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 3
  template<typename _Tp1, typename _Tp2> class _Constant;
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_before.h" 3
  struct __abs
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return abs(__t); }
  };

  struct __cos
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return cos(__t); }
  };

  struct __acos
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return acos(__t); }
  };

  struct __cosh
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return cosh(__t); }
  };

  struct __sin
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return sin(__t); }
  };

  struct __asin
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return asin(__t); }
  };

  struct __sinh
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return sinh(__t); }
  };

  struct __tan
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return tan(__t); }
  };

  struct __atan
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return atan(__t); }
  };

  struct __tanh
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return tanh(__t); }
  };

  struct __exp
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return exp(__t); }
  };

  struct __log
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return log(__t); }
  };

  struct __log10
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return log10(__t); }
  };

  struct __sqrt
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return sqrt(__t); }
  };





  struct __unary_plus
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return +__t; }
  };

  struct __negate
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return -__t; }
  };

  struct __bitwise_not
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __t) const
      { return ~__t; }
  };

  struct __plus
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
  };

  struct __minus
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
  };

  struct __multiplies
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
  };

  struct __divides
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
  };

  struct __modulus
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
  };

  struct __bitwise_xor
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
  };

  struct __bitwise_and
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
  };

  struct __bitwise_or
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
  };

  struct __shift_left
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x << __y; }
  };

  struct __shift_right
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >> __y; }
  };

  struct __logical_and
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
  };

  struct __logical_or
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
  };

  struct __logical_not
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x) const { return !__x; }
  };

  struct __equal_to
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
  };

  struct __not_equal_to
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
  };

  struct __less
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
  };

  struct __greater
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
  };

  struct __less_equal
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
  };

  struct __greater_equal
  {
    template<typename _Tp>
      bool operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
  };


  struct __atan2
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return atan2(__x, __y); }
  };

  struct __pow
  {
    template<typename _Tp>
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
      { return pow(__x, __y); }
  };





  template<typename, typename _Tp>
    struct __fun
    {
      typedef _Tp result_type;
    };


  template<typename _Tp>
    struct __fun<__logical_not, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__logical_and, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__logical_or, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__less, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__greater, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__less_equal, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__greater_equal, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__equal_to, _Tp>
    {
      typedef bool result_type;
    };

  template<typename _Tp>
    struct __fun<__not_equal_to, _Tp>
    {
      typedef bool result_type;
    };





  template<typename _Dom, typename _Arg>
    class _FunBase
    {
    public:
      typedef typename _Dom::value_type value_type;

      _FunBase(const _Dom& __e, value_type __f(_Arg))
      : _M_expr(__e), _M_func(__f) {}

      value_type operator[](size_t __i) const
      { return _M_func (_M_expr[__i]); }

      size_t size() const { return _M_expr.size ();}

    private:
      const _Dom& _M_expr;
      value_type (*_M_func)(_Arg);
    };

  template<class _Dom>
    struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
    {
      typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
      typedef typename _Base::value_type value_type;
      typedef value_type _Tp;

      _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
    };

  template<typename _Tp>
    struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
    {
      typedef _FunBase<valarray<_Tp>, _Tp> _Base;
      typedef _Tp value_type;

      _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
    };

  template<class _Dom>
    struct _RefFunClos<_Expr, _Dom>
    : _FunBase<_Dom, const typename _Dom::value_type&>
    {
      typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
      typedef typename _Base::value_type value_type;
      typedef value_type _Tp;

      _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
      : _Base(__e, __f) {}
    };

  template<typename _Tp>
    struct _RefFunClos<_ValArray, _Tp>
    : _FunBase<valarray<_Tp>, const _Tp&>
    {
      typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
      typedef _Tp value_type;

      _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
      : _Base(__v, __f) {}
    };





  template<class _Oper, class _Arg>
    class _UnBase
    {
    public:
      typedef typename _Arg::value_type _Vt;
      typedef typename __fun<_Oper, _Vt>::result_type value_type;

      _UnBase(const _Arg& __e) : _M_expr(__e) {}

      value_type operator[](size_t __i) const
      { return _Oper()(_M_expr[__i]); }

      size_t size() const { return _M_expr.size(); }

    private:
      const _Arg& _M_expr;
    };

  template<class _Oper, class _Dom>
    struct _UnClos<_Oper, _Expr, _Dom>
    : _UnBase<_Oper, _Dom>
    {
      typedef _Dom _Arg;
      typedef _UnBase<_Oper, _Dom> _Base;
      typedef typename _Base::value_type value_type;

      _UnClos(const _Arg& __e) : _Base(__e) {}
    };

  template<class _Oper, typename _Tp>
    struct _UnClos<_Oper, _ValArray, _Tp>
    : _UnBase<_Oper, valarray<_Tp> >
    {
      typedef valarray<_Tp> _Arg;
      typedef _UnBase<_Oper, valarray<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _UnClos(const _Arg& __e) : _Base(__e) {}
    };






  template<class _Oper, class _FirstArg, class _SecondArg>
    class _BinBase
    {
    public:
      typedef typename _FirstArg::value_type _Vt;
      typedef typename __fun<_Oper, _Vt>::result_type value_type;

      _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
      : _M_expr1(__e1), _M_expr2(__e2) {}

      value_type operator[](size_t __i) const
      { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }

      size_t size() const { return _M_expr1.size(); }

    private:
      const _FirstArg& _M_expr1;
      const _SecondArg& _M_expr2;
    };


  template<class _Oper, class _Clos>
    class _BinBase2
    {
    public:
      typedef typename _Clos::value_type _Vt;
      typedef typename __fun<_Oper, _Vt>::result_type value_type;

      _BinBase2(const _Clos& __e, const _Vt& __t)
      : _M_expr1(__e), _M_expr2(__t) {}

      value_type operator[](size_t __i) const
      { return _Oper()(_M_expr1[__i], _M_expr2); }

      size_t size() const { return _M_expr1.size(); }

    private:
      const _Clos& _M_expr1;
      const _Vt& _M_expr2;
    };

  template<class _Oper, class _Clos>
    class _BinBase1
    {
    public:
      typedef typename _Clos::value_type _Vt;
      typedef typename __fun<_Oper, _Vt>::result_type value_type;

      _BinBase1(const _Vt& __t, const _Clos& __e)
      : _M_expr1(__t), _M_expr2(__e) {}

      value_type operator[](size_t __i) const
      { return _Oper()(_M_expr1, _M_expr2[__i]); }

      size_t size() const { return _M_expr2.size(); }

    private:
      const _Vt& _M_expr1;
      const _Clos& _M_expr2;
    };

  template<class _Oper, class _Dom1, class _Dom2>
    struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
    : _BinBase<_Oper, _Dom1, _Dom2>
    {
      typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
    };

  template<class _Oper, typename _Tp>
    struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp>
    : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
    {
      typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
      : _Base(__v, __w) {}
    };

  template<class _Oper, class _Dom>
    struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
    : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
    {
      typedef typename _Dom::value_type _Tp;
      typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
      : _Base(__e1, __e2) {}
    };

  template<class _Oper, class _Dom>
    struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
    : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
    {
      typedef typename _Dom::value_type _Tp;
      typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
      : _Base(__e1, __e2) {}
    };

  template<class _Oper, class _Dom>
    struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
    : _BinBase2<_Oper, _Dom>
    {
      typedef typename _Dom::value_type _Tp;
      typedef _BinBase2<_Oper,_Dom> _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
    };

  template<class _Oper, class _Dom>
    struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
    : _BinBase1<_Oper, _Dom>
    {
      typedef typename _Dom::value_type _Tp;
      typedef _BinBase1<_Oper, _Dom> _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
    };

  template<class _Oper, typename _Tp>
    struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
    : _BinBase2<_Oper, valarray<_Tp> >
    {
      typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
    };

  template<class _Oper, typename _Tp>
    struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
    : _BinBase1<_Oper, valarray<_Tp> >
    {
      typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
    };




  template<typename _Dom>
    class _SBase
    {
    public:
      typedef typename _Dom::value_type value_type;

      _SBase (const _Dom& __e, const slice& __s)
      : _M_expr (__e), _M_slice (__s) {}

      value_type
      operator[] (size_t __i) const
      { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }

      size_t
      size() const
      { return _M_slice.size (); }

    private:
      const _Dom& _M_expr;
      const slice& _M_slice;
    };

  template<typename _Tp>
    class _SBase<_Array<_Tp> >
    {
    public:
      typedef _Tp value_type;

      _SBase (_Array<_Tp> __a, const slice& __s)
      : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
 _M_stride (__s.stride()) {}

      value_type
      operator[] (size_t __i) const
      { return _M_array._M_data[__i * _M_stride]; }

      size_t
      size() const
      { return _M_size; }

    private:
      const _Array<_Tp> _M_array;
      const size_t _M_size;
      const size_t _M_stride;
    };

  template<class _Dom>
    struct _SClos<_Expr, _Dom>
    : _SBase<_Dom>
    {
      typedef _SBase<_Dom> _Base;
      typedef typename _Base::value_type value_type;

      _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
    };

  template<typename _Tp>
    struct _SClos<_ValArray, _Tp>
    : _SBase<_Array<_Tp> >
    {
      typedef _SBase<_Array<_Tp> > _Base;
      typedef _Tp value_type;

      _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
    };

}
# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
  template<class _Tp>
    class valarray
    {
      template<class _Op>
 struct _UnaryOp
 {
   typedef typename __fun<_Op, _Tp>::result_type __rt;
   typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
 };
    public:
      typedef _Tp value_type;



      valarray();


      explicit valarray(size_t);


      valarray(const _Tp&, size_t);


      valarray(const _Tp* __restrict__, size_t);


      valarray(const valarray&);


      valarray(const slice_array<_Tp>&);


      valarray(const gslice_array<_Tp>&);


      valarray(const mask_array<_Tp>&);


      valarray(const indirect_array<_Tp>&);






      template<class _Dom>
 valarray(const _Expr<_Dom, _Tp>& __e);

      ~valarray();
# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const valarray<_Tp>&);
# 179 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const _Tp&);
# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const slice_array<_Tp>&);
# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const gslice_array<_Tp>&);
# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const mask_array<_Tp>&);
# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp>& operator=(const indirect_array<_Tp>&);
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      template<class _Dom> valarray<_Tp>&
 operator= (const _Expr<_Dom, _Tp>&);
# 243 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Tp& operator[](size_t);



      const _Tp& operator[](size_t) const;
# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const;
# 272 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      slice_array<_Tp> operator[](slice);
# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const;
# 295 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      gslice_array<_Tp> operator[](const gslice&);
# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp> operator[](const valarray<bool>&) const;
# 323 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      mask_array<_Tp> operator[](const valarray<bool>&);
# 336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Expr<_IClos<_ValArray, _Tp>, _Tp>
        operator[](const valarray<size_t>&) const;
# 351 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      indirect_array<_Tp> operator[](const valarray<size_t>&);



      typename _UnaryOp<__unary_plus>::_Rt operator+() const;


      typename _UnaryOp<__negate>::_Rt operator-() const;


      typename _UnaryOp<__bitwise_not>::_Rt operator~() const;


      typename _UnaryOp<__logical_not>::_Rt operator!() const;



      valarray<_Tp>& operator*=(const _Tp&);


      valarray<_Tp>& operator/=(const _Tp&);


      valarray<_Tp>& operator%=(const _Tp&);


      valarray<_Tp>& operator+=(const _Tp&);


      valarray<_Tp>& operator-=(const _Tp&);


      valarray<_Tp>& operator^=(const _Tp&);


      valarray<_Tp>& operator&=(const _Tp&);


      valarray<_Tp>& operator|=(const _Tp&);


      valarray<_Tp>& operator<<=(const _Tp&);


      valarray<_Tp>& operator>>=(const _Tp&);


      valarray<_Tp>& operator*=(const valarray<_Tp>&);


      valarray<_Tp>& operator/=(const valarray<_Tp>&);


      valarray<_Tp>& operator%=(const valarray<_Tp>&);


      valarray<_Tp>& operator+=(const valarray<_Tp>&);


      valarray<_Tp>& operator-=(const valarray<_Tp>&);


      valarray<_Tp>& operator^=(const valarray<_Tp>&);


      valarray<_Tp>& operator|=(const valarray<_Tp>&);


      valarray<_Tp>& operator&=(const valarray<_Tp>&);


      valarray<_Tp>& operator<<=(const valarray<_Tp>&);


      valarray<_Tp>& operator>>=(const valarray<_Tp>&);

      template<class _Dom>
 valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
        valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
      template<class _Dom>
 valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&);



      size_t size() const;







      _Tp sum() const;


      _Tp min() const;


      _Tp max() const;
# 481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp> shift (int) const;
# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      valarray<_Tp> cshift(int) const;
# 510 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const;
# 522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const;
# 533 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
      void resize(size_t __size, _Tp __c = _Tp());

    private:
      size_t _M_size;
      _Tp* __restrict__ _M_data;

      friend class _Array<_Tp>;
    };

  template<typename _Tp>
    inline const _Tp&
    valarray<_Tp>::operator[](size_t __i) const
    {
      ;
      return _M_data[__i];
    }

  template<typename _Tp>
    inline _Tp&
    valarray<_Tp>::operator[](size_t __i)
    {
      ;
      return _M_data[__i];
    }



}

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3
#define _VALARRAY_AFTER_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3

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




  template<class _Dom>
    class _GBase
    {
    public:
      typedef typename _Dom::value_type value_type;

      _GBase (const _Dom& __e, const valarray<size_t>& __i)
      : _M_expr (__e), _M_index(__i) {}

      value_type
      operator[] (size_t __i) const
      { return _M_expr[_M_index[__i]]; }

      size_t
      size () const
      { return _M_index.size(); }

    private:
      const _Dom& _M_expr;
      const valarray<size_t>& _M_index;
    };

  template<typename _Tp>
    class _GBase<_Array<_Tp> >
    {
    public:
      typedef _Tp value_type;

      _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
      : _M_array (__a), _M_index(__i) {}

      value_type
      operator[] (size_t __i) const
      { return _M_array._M_data[_M_index[__i]]; }

      size_t
      size () const
      { return _M_index.size(); }

    private:
      const _Array<_Tp> _M_array;
      const valarray<size_t>& _M_index;
    };

  template<class _Dom>
    struct _GClos<_Expr, _Dom>
    : _GBase<_Dom>
    {
      typedef _GBase<_Dom> _Base;
      typedef typename _Base::value_type value_type;

      _GClos (const _Dom& __e, const valarray<size_t>& __i)
      : _Base (__e, __i) {}
    };

  template<typename _Tp>
    struct _GClos<_ValArray, _Tp>
    : _GBase<_Array<_Tp> >
    {
      typedef _GBase<_Array<_Tp> > _Base;
      typedef typename _Base::value_type value_type;

      _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
      : _Base (__a, __i) {}
    };




  template<class _Dom>
    class _IBase
    {
    public:
      typedef typename _Dom::value_type value_type;

      _IBase (const _Dom& __e, const valarray<size_t>& __i)
      : _M_expr (__e), _M_index (__i) {}

      value_type
      operator[] (size_t __i) const
      { return _M_expr[_M_index[__i]]; }

      size_t
      size() const
      { return _M_index.size(); }

    private:
      const _Dom& _M_expr;
      const valarray<size_t>& _M_index;
    };

  template<class _Dom>
    struct _IClos<_Expr, _Dom>
    : _IBase<_Dom>
    {
      typedef _IBase<_Dom> _Base;
      typedef typename _Base::value_type value_type;

      _IClos (const _Dom& __e, const valarray<size_t>& __i)
      : _Base (__e, __i) {}
    };

  template<typename _Tp>
    struct _IClos<_ValArray, _Tp>
    : _IBase<valarray<_Tp> >
    {
      typedef _IBase<valarray<_Tp> > _Base;
      typedef _Tp value_type;

      _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
      : _Base (__a, __i) {}
    };




  template<class _Clos, typename _Tp>
    class _Expr
    {
    public:
      typedef _Tp value_type;

      _Expr(const _Clos&);

      const _Clos& operator()() const;

      value_type operator[](size_t) const;
      valarray<value_type> operator[](slice) const;
      valarray<value_type> operator[](const gslice&) const;
      valarray<value_type> operator[](const valarray<bool>&) const;
      valarray<value_type> operator[](const valarray<size_t>&) const;

      _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
      operator+() const;

      _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
      operator-() const;

      _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
      operator~() const;

      _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
      operator!() const;

      size_t size() const;
      value_type sum() const;

      valarray<value_type> shift(int) const;
      valarray<value_type> cshift(int) const;

      value_type min() const;
      value_type max() const;

      valarray<value_type> apply(value_type (*)(const value_type&)) const;
      valarray<value_type> apply(value_type (*)(value_type)) const;

    private:
      const _Clos _M_closure;
    };

  template<class _Clos, typename _Tp>
    inline
    _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}

  template<class _Clos, typename _Tp>
    inline const _Clos&
    _Expr<_Clos, _Tp>::operator()() const
    { return _M_closure; }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::operator[](size_t __i) const
    { return _M_closure[__i]; }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](slice __s) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline size_t
    _Expr<_Clos, _Tp>::size() const
    { return _M_closure.size(); }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::shift(int __n) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::cshift(int __n) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
      return __v;
    }


  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::sum() const
    {
      size_t __n = _M_closure.size();
      if (__n == 0)
 return _Tp();
      else
 {
   _Tp __s = _M_closure[--__n];
   while (__n != 0)
     __s += _M_closure[--__n];
   return __s;
        }
    }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::min() const
    { return __valarray_min(_M_closure); }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::max() const
    { return __valarray_max(_M_closure); }

  template<class _Dom, typename _Tp>
    inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
    _Expr<_Dom, _Tp>::operator!() const
    {
      typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
      return _Expr<_Closure, bool>(_Closure(this->_M_closure));
    }

#define _DEFINE_EXPR_UNARY_OPERATOR(_Op,_Name) template<class _Dom, typename _Tp> inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> _Expr<_Dom, _Tp>::operator _Op() const { typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); }
# 330 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3
    template<class _Dom, typename _Tp> inline _Expr<_UnClos<__unary_plus, std::_Expr, _Dom>, _Tp> _Expr<_Dom, _Tp>::operator +() const { typedef _UnClos<__unary_plus, std::_Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); }
    template<class _Dom, typename _Tp> inline _Expr<_UnClos<__negate, std::_Expr, _Dom>, _Tp> _Expr<_Dom, _Tp>::operator -() const { typedef _UnClos<__negate, std::_Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); }
    template<class _Dom, typename _Tp> inline _Expr<_UnClos<__bitwise_not, std::_Expr, _Dom>, _Tp> _Expr<_Dom, _Tp>::operator ~() const { typedef _UnClos<__bitwise_not, std::_Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); }

#undef _DEFINE_EXPR_UNARY_OPERATOR

#define _DEFINE_EXPR_BINARY_OPERATOR(_Op,_Name) template<class _Dom1, class _Dom2> inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<_Name, typename _Dom1::value_type>::result_type> operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<_Name, _Arg>::result_type _Value; typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<_Name, typename _Dom::value_type>::result_type> operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<_Name, _Arg>::result_type _Value; typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<_Name, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<_Name, typename _Dom::value_type>::result_type> operator _Op(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<_Name, _Arg>::result_type _Value; typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<_Name, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<_Name, typename _Dom::value_type>::result_type> operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<_Name, _Arg>::result_type _Value; typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<_Name, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<_Name, typename _Dom::value_type>::result_type> operator _Op(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<_Name, _Tp>::result_type _Value; typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__plus, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__plus, typename _Dom1::value_type>::result_type> operator +(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__plus, _Arg>::result_type _Value; typedef _BinClos<__plus, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__plus, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__plus, typename _Dom::value_type>::result_type> operator +(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__plus, _Arg>::result_type _Value; typedef _BinClos<__plus, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__plus, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__plus, typename _Dom::value_type>::result_type> operator +(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__plus, _Arg>::result_type _Value; typedef _BinClos<__plus, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__plus, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__plus, typename _Dom::value_type>::result_type> operator +(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__plus, _Arg>::result_type _Value; typedef _BinClos<__plus, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__plus, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__plus, typename _Dom::value_type>::result_type> operator +(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__plus, _Tp>::result_type _Value; typedef _BinClos<__plus, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__minus, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__minus, typename _Dom1::value_type>::result_type> operator -(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__minus, _Arg>::result_type _Value; typedef _BinClos<__minus, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__minus, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__minus, typename _Dom::value_type>::result_type> operator -(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__minus, _Arg>::result_type _Value; typedef _BinClos<__minus, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__minus, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__minus, typename _Dom::value_type>::result_type> operator -(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__minus, _Arg>::result_type _Value; typedef _BinClos<__minus, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__minus, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__minus, typename _Dom::value_type>::result_type> operator -(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__minus, _Arg>::result_type _Value; typedef _BinClos<__minus, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__minus, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__minus, typename _Dom::value_type>::result_type> operator -(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__minus, _Tp>::result_type _Value; typedef _BinClos<__minus, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__multiplies, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__multiplies, typename _Dom1::value_type>::result_type> operator *(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__multiplies, _Arg>::result_type _Value; typedef _BinClos<__multiplies, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__multiplies, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__multiplies, typename _Dom::value_type>::result_type> operator *(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__multiplies, _Arg>::result_type _Value; typedef _BinClos<__multiplies, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__multiplies, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__multiplies, typename _Dom::value_type>::result_type> operator *(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__multiplies, _Arg>::result_type _Value; typedef _BinClos<__multiplies, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__multiplies, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__multiplies, typename _Dom::value_type>::result_type> operator *(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__multiplies, _Arg>::result_type _Value; typedef _BinClos<__multiplies, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__multiplies, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__multiplies, typename _Dom::value_type>::result_type> operator *(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__multiplies, _Tp>::result_type _Value; typedef _BinClos<__multiplies, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__divides, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__divides, typename _Dom1::value_type>::result_type> operator /(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__divides, _Arg>::result_type _Value; typedef _BinClos<__divides, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__divides, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__divides, typename _Dom::value_type>::result_type> operator /(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__divides, _Arg>::result_type _Value; typedef _BinClos<__divides, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__divides, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__divides, typename _Dom::value_type>::result_type> operator /(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__divides, _Arg>::result_type _Value; typedef _BinClos<__divides, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__divides, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__divides, typename _Dom::value_type>::result_type> operator /(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__divides, _Arg>::result_type _Value; typedef _BinClos<__divides, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__divides, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__divides, typename _Dom::value_type>::result_type> operator /(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__divides, _Tp>::result_type _Value; typedef _BinClos<__divides, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__modulus, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__modulus, typename _Dom1::value_type>::result_type> operator %(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__modulus, _Arg>::result_type _Value; typedef _BinClos<__modulus, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__modulus, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__modulus, typename _Dom::value_type>::result_type> operator %(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__modulus, _Arg>::result_type _Value; typedef _BinClos<__modulus, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__modulus, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__modulus, typename _Dom::value_type>::result_type> operator %(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__modulus, _Arg>::result_type _Value; typedef _BinClos<__modulus, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__modulus, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__modulus, typename _Dom::value_type>::result_type> operator %(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__modulus, _Arg>::result_type _Value; typedef _BinClos<__modulus, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__modulus, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__modulus, typename _Dom::value_type>::result_type> operator %(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__modulus, _Tp>::result_type _Value; typedef _BinClos<__modulus, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__bitwise_xor, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__bitwise_xor, typename _Dom1::value_type>::result_type> operator ^(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__bitwise_xor, _Arg>::result_type _Value; typedef _BinClos<__bitwise_xor, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_xor, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_xor, typename _Dom::value_type>::result_type> operator ^(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_xor, _Arg>::result_type _Value; typedef _BinClos<__bitwise_xor, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_xor, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_xor, typename _Dom::value_type>::result_type> operator ^(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_xor, _Arg>::result_type _Value; typedef _BinClos<__bitwise_xor, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_xor, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_xor, typename _Dom::value_type>::result_type> operator ^(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_xor, _Arg>::result_type _Value; typedef _BinClos<__bitwise_xor, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_xor, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_xor, typename _Dom::value_type>::result_type> operator ^(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Value; typedef _BinClos<__bitwise_xor, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__bitwise_and, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__bitwise_and, typename _Dom1::value_type>::result_type> operator &(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__bitwise_and, _Arg>::result_type _Value; typedef _BinClos<__bitwise_and, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_and, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_and, typename _Dom::value_type>::result_type> operator &(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_and, _Arg>::result_type _Value; typedef _BinClos<__bitwise_and, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_and, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_and, typename _Dom::value_type>::result_type> operator &(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_and, _Arg>::result_type _Value; typedef _BinClos<__bitwise_and, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_and, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_and, typename _Dom::value_type>::result_type> operator &(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_and, _Arg>::result_type _Value; typedef _BinClos<__bitwise_and, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_and, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_and, typename _Dom::value_type>::result_type> operator &(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__bitwise_and, _Tp>::result_type _Value; typedef _BinClos<__bitwise_and, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__bitwise_or, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__bitwise_or, typename _Dom1::value_type>::result_type> operator |(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__bitwise_or, _Arg>::result_type _Value; typedef _BinClos<__bitwise_or, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_or, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_or, typename _Dom::value_type>::result_type> operator |(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_or, _Arg>::result_type _Value; typedef _BinClos<__bitwise_or, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_or, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_or, typename _Dom::value_type>::result_type> operator |(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_or, _Arg>::result_type _Value; typedef _BinClos<__bitwise_or, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__bitwise_or, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__bitwise_or, typename _Dom::value_type>::result_type> operator |(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__bitwise_or, _Arg>::result_type _Value; typedef _BinClos<__bitwise_or, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__bitwise_or, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__bitwise_or, typename _Dom::value_type>::result_type> operator |(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__bitwise_or, _Tp>::result_type _Value; typedef _BinClos<__bitwise_or, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__shift_left, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__shift_left, typename _Dom1::value_type>::result_type> operator <<(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__shift_left, _Arg>::result_type _Value; typedef _BinClos<__shift_left, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__shift_left, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__shift_left, typename _Dom::value_type>::result_type> operator <<(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_left, _Arg>::result_type _Value; typedef _BinClos<__shift_left, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__shift_left, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__shift_left, typename _Dom::value_type>::result_type> operator <<(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_left, _Arg>::result_type _Value; typedef _BinClos<__shift_left, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__shift_left, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__shift_left, typename _Dom::value_type>::result_type> operator <<(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_left, _Arg>::result_type _Value; typedef _BinClos<__shift_left, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__shift_left, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__shift_left, typename _Dom::value_type>::result_type> operator <<(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__shift_left, _Tp>::result_type _Value; typedef _BinClos<__shift_left, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__shift_right, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__shift_right, typename _Dom1::value_type>::result_type> operator >>(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__shift_right, _Arg>::result_type _Value; typedef _BinClos<__shift_right, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__shift_right, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__shift_right, typename _Dom::value_type>::result_type> operator >>(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_right, _Arg>::result_type _Value; typedef _BinClos<__shift_right, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__shift_right, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__shift_right, typename _Dom::value_type>::result_type> operator >>(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_right, _Arg>::result_type _Value; typedef _BinClos<__shift_right, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__shift_right, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__shift_right, typename _Dom::value_type>::result_type> operator >>(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__shift_right, _Arg>::result_type _Value; typedef _BinClos<__shift_right, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__shift_right, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__shift_right, typename _Dom::value_type>::result_type> operator >>(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__shift_right, _Tp>::result_type _Value; typedef _BinClos<__shift_right, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__logical_and, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__logical_and, typename _Dom1::value_type>::result_type> operator &&(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__logical_and, _Arg>::result_type _Value; typedef _BinClos<__logical_and, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__logical_and, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__logical_and, typename _Dom::value_type>::result_type> operator &&(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_and, _Arg>::result_type _Value; typedef _BinClos<__logical_and, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__logical_and, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__logical_and, typename _Dom::value_type>::result_type> operator &&(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_and, _Arg>::result_type _Value; typedef _BinClos<__logical_and, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__logical_and, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__logical_and, typename _Dom::value_type>::result_type> operator &&(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_and, _Arg>::result_type _Value; typedef _BinClos<__logical_and, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__logical_and, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__logical_and, typename _Dom::value_type>::result_type> operator &&(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__logical_and, _Tp>::result_type _Value; typedef _BinClos<__logical_and, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__logical_or, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__logical_or, typename _Dom1::value_type>::result_type> operator ||(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__logical_or, _Arg>::result_type _Value; typedef _BinClos<__logical_or, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__logical_or, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__logical_or, typename _Dom::value_type>::result_type> operator ||(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_or, _Arg>::result_type _Value; typedef _BinClos<__logical_or, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__logical_or, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__logical_or, typename _Dom::value_type>::result_type> operator ||(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_or, _Arg>::result_type _Value; typedef _BinClos<__logical_or, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__logical_or, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__logical_or, typename _Dom::value_type>::result_type> operator ||(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__logical_or, _Arg>::result_type _Value; typedef _BinClos<__logical_or, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__logical_or, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__logical_or, typename _Dom::value_type>::result_type> operator ||(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__logical_or, _Tp>::result_type _Value; typedef _BinClos<__logical_or, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__equal_to, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__equal_to, typename _Dom1::value_type>::result_type> operator ==(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__equal_to, _Arg>::result_type _Value; typedef _BinClos<__equal_to, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__equal_to, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__equal_to, typename _Dom::value_type>::result_type> operator ==(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__equal_to, _Arg>::result_type _Value; typedef _BinClos<__equal_to, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__equal_to, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__equal_to, typename _Dom::value_type>::result_type> operator ==(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__equal_to, _Arg>::result_type _Value; typedef _BinClos<__equal_to, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__equal_to, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__equal_to, typename _Dom::value_type>::result_type> operator ==(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__equal_to, _Arg>::result_type _Value; typedef _BinClos<__equal_to, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__equal_to, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__equal_to, typename _Dom::value_type>::result_type> operator ==(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__equal_to, _Tp>::result_type _Value; typedef _BinClos<__equal_to, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__not_equal_to, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__not_equal_to, typename _Dom1::value_type>::result_type> operator !=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__not_equal_to, _Arg>::result_type _Value; typedef _BinClos<__not_equal_to, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__not_equal_to, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__not_equal_to, typename _Dom::value_type>::result_type> operator !=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__not_equal_to, _Arg>::result_type _Value; typedef _BinClos<__not_equal_to, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__not_equal_to, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__not_equal_to, typename _Dom::value_type>::result_type> operator !=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__not_equal_to, _Arg>::result_type _Value; typedef _BinClos<__not_equal_to, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__not_equal_to, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__not_equal_to, typename _Dom::value_type>::result_type> operator !=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__not_equal_to, _Arg>::result_type _Value; typedef _BinClos<__not_equal_to, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__not_equal_to, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__not_equal_to, typename _Dom::value_type>::result_type> operator !=(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__not_equal_to, _Tp>::result_type _Value; typedef _BinClos<__not_equal_to, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__less, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__less, typename _Dom1::value_type>::result_type> operator <(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__less, _Arg>::result_type _Value; typedef _BinClos<__less, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__less, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__less, typename _Dom::value_type>::result_type> operator <(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less, _Arg>::result_type _Value; typedef _BinClos<__less, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__less, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__less, typename _Dom::value_type>::result_type> operator <(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less, _Arg>::result_type _Value; typedef _BinClos<__less, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__less, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__less, typename _Dom::value_type>::result_type> operator <(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less, _Arg>::result_type _Value; typedef _BinClos<__less, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__less, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__less, typename _Dom::value_type>::result_type> operator <(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__less, _Tp>::result_type _Value; typedef _BinClos<__less, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__greater, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__greater, typename _Dom1::value_type>::result_type> operator >(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__greater, _Arg>::result_type _Value; typedef _BinClos<__greater, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__greater, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__greater, typename _Dom::value_type>::result_type> operator >(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater, _Arg>::result_type _Value; typedef _BinClos<__greater, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__greater, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__greater, typename _Dom::value_type>::result_type> operator >(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater, _Arg>::result_type _Value; typedef _BinClos<__greater, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__greater, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__greater, typename _Dom::value_type>::result_type> operator >(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater, _Arg>::result_type _Value; typedef _BinClos<__greater, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__greater, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__greater, typename _Dom::value_type>::result_type> operator >(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__greater, _Tp>::result_type _Value; typedef _BinClos<__greater, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__less_equal, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__less_equal, typename _Dom1::value_type>::result_type> operator <=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__less_equal, _Arg>::result_type _Value; typedef _BinClos<__less_equal, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__less_equal, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__less_equal, typename _Dom::value_type>::result_type> operator <=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less_equal, _Arg>::result_type _Value; typedef _BinClos<__less_equal, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__less_equal, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__less_equal, typename _Dom::value_type>::result_type> operator <=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less_equal, _Arg>::result_type _Value; typedef _BinClos<__less_equal, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__less_equal, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__less_equal, typename _Dom::value_type>::result_type> operator <=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__less_equal, _Arg>::result_type _Value; typedef _BinClos<__less_equal, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__less_equal, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__less_equal, typename _Dom::value_type>::result_type> operator <=(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__less_equal, _Tp>::result_type _Value; typedef _BinClos<__less_equal, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }
    template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__greater_equal, _Expr, _Expr, _Dom1, _Dom2>, typename __fun<__greater_equal, typename _Dom1::value_type>::result_type> operator >=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun<__greater_equal, _Arg>::result_type _Value; typedef _BinClos<__greater_equal, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template<class _Dom> inline _Expr<_BinClos<__greater_equal, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename __fun<__greater_equal, typename _Dom::value_type>::result_type> operator >=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater_equal, _Arg>::result_type _Value; typedef _BinClos<__greater_equal, _Expr, _Constant, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template<class _Dom> inline _Expr<_BinClos<__greater_equal, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__greater_equal, typename _Dom::value_type>::result_type> operator >=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater_equal, _Arg>::result_type _Value; typedef _BinClos<__greater_equal, _Constant, _Expr, _Arg, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template<class _Dom> inline _Expr<_BinClos<__greater_equal, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename __fun<__greater_equal, typename _Dom::value_type>::result_type> operator >=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun<__greater_equal, _Arg>::result_type _Value; typedef _BinClos<__greater_equal, _Expr, _ValArray, _Dom, _Arg> _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__greater_equal, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename __fun<__greater_equal, typename _Dom::value_type>::result_type> operator >=(const valarray<typename _Dom::value_type>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun<__greater_equal, _Tp>::result_type _Value; typedef _BinClos<__greater_equal, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); }

#undef _DEFINE_EXPR_BINARY_OPERATOR

#define _DEFINE_EXPR_UNARY_FUNCTION(_Name) template<class _Dom> inline _Expr<_UnClos<__ ##_Name, _Expr, _Dom>, typename _Dom::value_type> _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__ ##_Name, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__ ##_Name, _ValArray, _Tp>, _Tp> _Name(const valarray<_Tp>& __v) { typedef _UnClos<__ ##_Name, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3
    template<class _Dom> inline _Expr<_UnClos<__abs, _Expr, _Dom>, typename _Dom::value_type> abs(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__abs, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__abs, _ValArray, _Tp>, _Tp> abs(const valarray<_Tp>& __v) { typedef _UnClos<__abs, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__cos, _Expr, _Dom>, typename _Dom::value_type> cos(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__cos, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__cos, _ValArray, _Tp>, _Tp> cos(const valarray<_Tp>& __v) { typedef _UnClos<__cos, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__acos, _Expr, _Dom>, typename _Dom::value_type> acos(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__acos, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__acos, _ValArray, _Tp>, _Tp> acos(const valarray<_Tp>& __v) { typedef _UnClos<__acos, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__cosh, _Expr, _Dom>, typename _Dom::value_type> cosh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__cosh, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__cosh, _ValArray, _Tp>, _Tp> cosh(const valarray<_Tp>& __v) { typedef _UnClos<__cosh, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__sin, _Expr, _Dom>, typename _Dom::value_type> sin(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__sin, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__sin, _ValArray, _Tp>, _Tp> sin(const valarray<_Tp>& __v) { typedef _UnClos<__sin, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__asin, _Expr, _Dom>, typename _Dom::value_type> asin(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__asin, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__asin, _ValArray, _Tp>, _Tp> asin(const valarray<_Tp>& __v) { typedef _UnClos<__asin, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__sinh, _Expr, _Dom>, typename _Dom::value_type> sinh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__sinh, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__sinh, _ValArray, _Tp>, _Tp> sinh(const valarray<_Tp>& __v) { typedef _UnClos<__sinh, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__tan, _Expr, _Dom>, typename _Dom::value_type> tan(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__tan, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__tan, _ValArray, _Tp>, _Tp> tan(const valarray<_Tp>& __v) { typedef _UnClos<__tan, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__tanh, _Expr, _Dom>, typename _Dom::value_type> tanh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__tanh, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__tanh, _ValArray, _Tp>, _Tp> tanh(const valarray<_Tp>& __v) { typedef _UnClos<__tanh, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__atan, _Expr, _Dom>, typename _Dom::value_type> atan(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__atan, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__atan, _ValArray, _Tp>, _Tp> atan(const valarray<_Tp>& __v) { typedef _UnClos<__atan, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__exp, _Expr, _Dom>, typename _Dom::value_type> exp(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__exp, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__exp, _ValArray, _Tp>, _Tp> exp(const valarray<_Tp>& __v) { typedef _UnClos<__exp, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__log, _Expr, _Dom>, typename _Dom::value_type> log(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__log, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__log, _ValArray, _Tp>, _Tp> log(const valarray<_Tp>& __v) { typedef _UnClos<__log, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__log10, _Expr, _Dom>, typename _Dom::value_type> log10(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__log10, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__log10, _ValArray, _Tp>, _Tp> log10(const valarray<_Tp>& __v) { typedef _UnClos<__log10, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }
    template<class _Dom> inline _Expr<_UnClos<__sqrt, _Expr, _Dom>, typename _Dom::value_type> sqrt(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos<__sqrt, _Expr, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template<typename _Tp> inline _Expr<_UnClos<__sqrt, _ValArray, _Tp>, _Tp> sqrt(const valarray<_Tp>& __v) { typedef _UnClos<__sqrt, _ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); }

#undef _DEFINE_EXPR_UNARY_FUNCTION

#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__ ##_Fun, _Expr, _Expr, _Dom1, _Dom2>, typename _Dom1::value_type> _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, const _Expr<_Dom2, typename _Dom2::value_type>& __e2) { typedef typename _Dom1::value_type _Tp; typedef _BinClos<__ ##_Fun, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); } template<class _Dom> inline _Expr<_BinClos<__ ##_Fun, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename _Dom::value_type> _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__ ##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__ ##_Fun, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> _Fun(const valarray<typename _Dom::valarray>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__ ##_Fun, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __e())); } template<class _Dom> inline _Expr<_BinClos<__ ##_Fun, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename _Dom::value_type> _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__ ##_Fun, _Expr, _Constant, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); } template<class _Dom> inline _Expr<_BinClos<__ ##_Fun, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> _Fun(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__ ##_Fun, _Constant, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __e())); } template<typename _Tp> inline _Expr<_BinClos<__ ##_Fun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { typedef _BinClos<__ ##_Fun, _ValArray, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__ ##_Fun, _ValArray, _Constant, _Tp, _Tp>, _Tp> _Fun(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__ ##_Fun, _ValArray, _Constant, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__ ##_Fun, _Constant, _ValArray, _Tp, _Tp>, _Tp> _Fun(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__ ##_Fun, _Constant, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __v)); }
# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/valarray_after.h" 3
template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__atan2, _Expr, _Expr, _Dom1, _Dom2>, typename _Dom1::value_type> atan2(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, const _Expr<_Dom2, typename _Dom2::value_type>& __e2) { typedef typename _Dom1::value_type _Tp; typedef _BinClos<__atan2, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); } template<class _Dom> inline _Expr<_BinClos<__atan2, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename _Dom::value_type> atan2(const _Expr<_Dom, typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__atan2, _Expr, _ValArray, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__atan2, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> atan2(const valarray<typename _Dom::valarray>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__atan2, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __e())); } template<class _Dom> inline _Expr<_BinClos<__atan2, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename _Dom::value_type> atan2(const _Expr<_Dom, typename _Dom::value_type>& __e, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__atan2, _Expr, _Constant, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); } template<class _Dom> inline _Expr<_BinClos<__atan2, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> atan2(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__atan2, _Constant, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __e())); } template<typename _Tp> inline _Expr<_BinClos<__atan2, _ValArray, _ValArray, _Tp, _Tp>, _Tp> atan2(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { typedef _BinClos<__atan2, _ValArray, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__atan2, _ValArray, _Constant, _Tp, _Tp>, _Tp> atan2(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__atan2, _ValArray, _Constant, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__atan2, _Constant, _ValArray, _Tp, _Tp>, _Tp> atan2(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__atan2, _Constant, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __v)); }
template<class _Dom1, class _Dom2> inline _Expr<_BinClos<__pow, _Expr, _Expr, _Dom1, _Dom2>, typename _Dom1::value_type> pow(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, const _Expr<_Dom2, typename _Dom2::value_type>& __e2) { typedef typename _Dom1::value_type _Tp; typedef _BinClos<__pow, _Expr, _Expr, _Dom1, _Dom2> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); } template<class _Dom> inline _Expr<_BinClos<__pow, _Expr, _ValArray, _Dom, typename _Dom::value_type>, typename _Dom::value_type> pow(const _Expr<_Dom, typename _Dom::value_type>& __e, const valarray<typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__pow, _Expr, _ValArray, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); } template<class _Dom> inline _Expr<_BinClos<__pow, _ValArray, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> pow(const valarray<typename _Dom::valarray>& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__pow, _ValArray, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __e())); } template<class _Dom> inline _Expr<_BinClos<__pow, _Expr, _Constant, _Dom, typename _Dom::value_type>, typename _Dom::value_type> pow(const _Expr<_Dom, typename _Dom::value_type>& __e, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__pow, _Expr, _Constant, _Dom, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); } template<class _Dom> inline _Expr<_BinClos<__pow, _Constant, _Expr, typename _Dom::value_type, _Dom>, typename _Dom::value_type> pow(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos<__pow, _Constant, _Expr, _Tp, _Dom> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __e())); } template<typename _Tp> inline _Expr<_BinClos<__pow, _ValArray, _ValArray, _Tp, _Tp>, _Tp> pow(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { typedef _BinClos<__pow, _ValArray, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__pow, _ValArray, _Constant, _Tp, _Tp>, _Tp> pow(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__pow, _ValArray, _Constant, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__pow, _Constant, _ValArray, _Tp, _Tp>, _Tp> pow(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__pow, _Constant, _ValArray, _Tp, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __v)); }

#undef _DEFINE_EXPR_BINARY_FUNCTION

}
# 563 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice.h" 3
#define _GSLICE_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice.h" 3
  class gslice
  {
  public:

    gslice();
# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice.h" 3
    gslice(size_t, const valarray<size_t>&, const valarray<size_t>&);





    gslice(const gslice&);


    ~gslice();



    gslice& operator=(const gslice&);


    size_t start() const;


    valarray<size_t> size() const;


    valarray<size_t> stride() const;

  private:
    struct _Indexer
    {
      size_t _M_count;
      size_t _M_start;
      valarray<size_t> _M_size;
      valarray<size_t> _M_stride;
      valarray<size_t> _M_index;

      _Indexer()
      : _M_count(1), _M_start(0), _M_size(), _M_stride(), _M_index() {}

      _Indexer(size_t, const valarray<size_t>&,
        const valarray<size_t>&);

      void
      _M_increment_use()
      { ++_M_count; }

      size_t
      _M_decrement_use()
      { return --_M_count; }
    };

    _Indexer* _M_index;

    template<typename _Tp> friend class valarray;
  };

  inline size_t
  gslice::start() const
  { return _M_index ? _M_index->_M_start : 0; }

  inline valarray<size_t>
  gslice::size() const
  { return _M_index ? _M_index->_M_size : valarray<size_t>(); }

  inline valarray<size_t>
  gslice::stride() const
  { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }



  inline
  gslice::gslice()
  : _M_index(new gslice::_Indexer()) {}

  inline
  gslice::gslice(size_t __o, const valarray<size_t>& __l,
   const valarray<size_t>& __s)
  : _M_index(new gslice::_Indexer(__o, __l, __s)) {}

  inline
  gslice::gslice(const gslice& __g)
  : _M_index(__g._M_index)
  { if (_M_index) _M_index->_M_increment_use(); }

  inline
  gslice::~gslice()
  {
    if (_M_index && _M_index->_M_decrement_use() == 0)
      delete _M_index;
  }

  inline gslice&
  gslice::operator=(const gslice& __g)
  {
    if (__g._M_index)
      __g._M_index->_M_increment_use();
    if (_M_index && _M_index->_M_decrement_use() == 0)
      delete _M_index;
    _M_index = __g._M_index;
    return *this;
  }



}
# 565 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice_array.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice_array.h" 3
#define _GSLICE_ARRAY_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice_array.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice_array.h" 3
  template<typename _Tp>
    class gslice_array
    {
    public:
      typedef _Tp value_type;





      gslice_array(const gslice_array&);



      gslice_array& operator=(const gslice_array&);


      void operator=(const valarray<_Tp>&) const;

      void operator*=(const valarray<_Tp>&) const;

      void operator/=(const valarray<_Tp>&) const;

      void operator%=(const valarray<_Tp>&) const;

      void operator+=(const valarray<_Tp>&) const;

      void operator-=(const valarray<_Tp>&) const;

      void operator^=(const valarray<_Tp>&) const;

      void operator&=(const valarray<_Tp>&) const;

      void operator|=(const valarray<_Tp>&) const;

      void operator<<=(const valarray<_Tp>&) const;

      void operator>>=(const valarray<_Tp>&) const;

      void operator=(const _Tp&) const;

      template<class _Dom>
        void operator=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator*=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator/=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator%=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator+=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator-=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator^=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator&=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator|=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator<<=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
        void operator>>=(const _Expr<_Dom, _Tp>&) const;

    private:
      _Array<_Tp> _M_array;
      const valarray<size_t>& _M_index;

      friend class valarray<_Tp>;

      gslice_array(_Array<_Tp>, const valarray<size_t>&);


      gslice_array();
    };

  template<typename _Tp>
    inline
    gslice_array<_Tp>::gslice_array(_Array<_Tp> __a,
        const valarray<size_t>& __i)
    : _M_array(__a), _M_index(__i) {}

  template<typename _Tp>
    inline
    gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
    : _M_array(__a._M_array), _M_index(__a._M_index) {}

  template<typename _Tp>
    inline gslice_array<_Tp>&
    gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a)
    {
      std::__valarray_copy(_Array<_Tp>(__a._M_array),
      _Array<size_t>(__a._M_index), _M_index.size(),
      _M_array, _Array<size_t>(_M_index));
      return *this;
    }

  template<typename _Tp>
    inline void
    gslice_array<_Tp>::operator=(const _Tp& __t) const
    {
      std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
      _M_index.size(), __t);
    }

  template<typename _Tp>
    inline void
    gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    {
      std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
      _M_array, _Array<size_t>(_M_index));
    }

  template<typename _Tp>
    template<class _Dom>
      inline void
      gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
      {
 std::__valarray_copy (__e, _M_index.size(), _M_array,
         _Array<size_t>(_M_index));
      }

#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) template<typename _Tp> inline void gslice_array<_Tp>::operator _Op ##=(const valarray<_Tp>& __v) const { _Array_augmented_ ##_Name(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator _Op ##= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented_ ##_Name(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/gslice_array.h" 3
template<typename _Tp> inline void gslice_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator *= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___multiplies(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator /= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___divides(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator %= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___modulus(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator += (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___plus(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator -= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___minus(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator ^= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator &= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator |= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator <<= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_left(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }
template<typename _Tp> inline void gslice_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _Array<size_t>(_M_index), _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void gslice_array<_Tp>::operator >>= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_right(_M_array, _Array<size_t>(_M_index), __e, _M_index.size()); }

#undef _DEFINE_VALARRAY_OPERATOR



}
# 566 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/mask_array.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/mask_array.h" 3
#define _MASK_ARRAY_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/mask_array.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/mask_array.h" 3
  template <class _Tp>
    class mask_array
    {
    public:
      typedef _Tp value_type;





      mask_array (const mask_array&);



      mask_array& operator=(const mask_array&);

      void operator=(const valarray<_Tp>&) const;

      void operator*=(const valarray<_Tp>&) const;

      void operator/=(const valarray<_Tp>&) const;

      void operator%=(const valarray<_Tp>&) const;

      void operator+=(const valarray<_Tp>&) const;

      void operator-=(const valarray<_Tp>&) const;

      void operator^=(const valarray<_Tp>&) const;

      void operator&=(const valarray<_Tp>&) const;

      void operator|=(const valarray<_Tp>&) const;

      void operator<<=(const valarray<_Tp>&) const;

      void operator>>=(const valarray<_Tp>&) const;

      void operator=(const _Tp&) const;



      template<class _Dom>
        void operator=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator*=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator/=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator%=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator+=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator-=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator^=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator&=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator|=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator<<=(const _Expr<_Dom,_Tp>&) const;
      template<class _Dom>
        void operator>>=(const _Expr<_Dom,_Tp>&) const;

    private:
      mask_array(_Array<_Tp>, size_t, _Array<bool>);
      friend class valarray<_Tp>;

      const size_t _M_sz;
      const _Array<bool> _M_mask;
      const _Array<_Tp> _M_array;


      mask_array();
    };

  template<typename _Tp>
    inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a)
    : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {}

  template<typename _Tp>
    inline
    mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array<bool> __m)
    : _M_sz(__s), _M_mask(__m), _M_array(__a) {}

  template<typename _Tp>
    inline mask_array<_Tp>&
    mask_array<_Tp>::operator=(const mask_array<_Tp>& __a)
    {
      std::__valarray_copy(__a._M_array, __a._M_mask,
      _M_sz, _M_array, _M_mask);
      return *this;
    }

  template<typename _Tp>
    inline void
    mask_array<_Tp>::operator=(const _Tp& __t) const
    { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); }

  template<typename _Tp>
    inline void
    mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }

  template<typename _Tp>
    template<class _Ex>
      inline void
      mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const
      { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); }

#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) template<typename _Tp> inline void mask_array<_Tp>::operator _Op ##=(const valarray<_Tp>& __v) const { _Array_augmented_ ##_Name(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator _Op ##=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented_ ##_Name(_M_array, _M_mask, __e, __e.size()); }
# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/mask_array.h" 3
template<typename _Tp> inline void mask_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator *=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator /=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___divides(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator %=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator +=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___plus(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator -=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___minus(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator ^=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator &=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator |=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator <<=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_mask, __e, __e.size()); }
template<typename _Tp> inline void mask_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template<typename _Tp> template<class _Dom> inline void mask_array<_Tp>::operator >>=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_mask, __e, __e.size()); }

#undef _DEFINE_VALARRAY_OPERATOR



}
# 567 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/indirect_array.h" 1 3
# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/indirect_array.h" 3
#define _INDIRECT_ARRAY_H 1

       
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/indirect_array.h" 3

namespace std __attribute__ ((__visibility__ ("default"))) {
# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/indirect_array.h" 3
  template <class _Tp>
    class indirect_array
    {
    public:
      typedef _Tp value_type;





      indirect_array(const indirect_array&);



      indirect_array& operator=(const indirect_array&);


      void operator=(const valarray<_Tp>&) const;

      void operator*=(const valarray<_Tp>&) const;

      void operator/=(const valarray<_Tp>&) const;

      void operator%=(const valarray<_Tp>&) const;

      void operator+=(const valarray<_Tp>&) const;

      void operator-=(const valarray<_Tp>&) const;

      void operator^=(const valarray<_Tp>&) const;

      void operator&=(const valarray<_Tp>&) const;

      void operator|=(const valarray<_Tp>&) const;

      void operator<<=(const valarray<_Tp>&) const;

      void operator>>=(const valarray<_Tp>&) const;

      void operator= (const _Tp&) const;


      template<class _Dom>
      void operator=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator*=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator/=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator%=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator+=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator-=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator^=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator&=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator|=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator<<=(const _Expr<_Dom, _Tp>&) const;
      template<class _Dom>
      void operator>>=(const _Expr<_Dom, _Tp>&) const;

    private:

      indirect_array(_Array<_Tp>, size_t, _Array<size_t>);

      friend class valarray<_Tp>;
      friend class gslice_array<_Tp>;

      const size_t _M_sz;
      const _Array<size_t> _M_index;
      const _Array<_Tp> _M_array;


      indirect_array();
    };

  template<typename _Tp>
    inline
    indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
    : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}

  template<typename _Tp>
    inline
    indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
     _Array<size_t> __i)
    : _M_sz(__s), _M_index(__i), _M_array(__a) {}

  template<typename _Tp>
    inline indirect_array<_Tp>&
    indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
    {
      std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array,
      _M_index);
      return *this;
    }

  template<typename _Tp>
    inline void
    indirect_array<_Tp>::operator=(const _Tp& __t) const
    { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }

  template<typename _Tp>
    inline void
    indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }

  template<typename _Tp>
    template<class _Dom>
      inline void
      indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
      { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }

#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) template<typename _Tp> inline void indirect_array<_Tp>::operator _Op ##=(const valarray<_Tp>& __v) const { _Array_augmented_ ##_Name(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator _Op ##=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented_ ##_Name(_M_array, _M_index, __e, _M_sz); }
# 193 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/indirect_array.h" 3
template<typename _Tp> inline void indirect_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator *=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator /=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___divides(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator %=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator +=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___plus(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator -=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___minus(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator ^=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator &=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator |=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator <<=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_index, __e, _M_sz); }
template<typename _Tp> inline void indirect_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template<typename _Tp> template<class _Dom> inline void indirect_array<_Tp>::operator >>=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_index, __e, _M_sz); }

#undef _DEFINE_VALARRAY_OPERATOR



}
# 568 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 2 3

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






  template<typename _Tp>
    inline
    valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(size_t __n)
    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
    { std::__valarray_default_construct(_M_data, _M_data + __n); }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
    { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
    {
      ;
      std::__valarray_copy_construct(__p, __p + __n, _M_data);
    }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const valarray<_Tp>& __v)
    : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
    { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
         _M_data); }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
    : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
    {
      std::__valarray_copy_construct
 (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
    }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
    : _M_size(__ga._M_index.size()),
      _M_data(__valarray_get_storage<_Tp>(_M_size))
    {
      std::__valarray_copy_construct
 (__ga._M_array, _Array<size_t>(__ga._M_index),
  _Array<_Tp>(_M_data), _M_size);
    }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
    : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
    {
      std::__valarray_copy_construct
 (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
    }

  template<typename _Tp>
    inline
    valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
    : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
    {
      std::__valarray_copy_construct
 (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
    }
# 654 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
  template<typename _Tp> template<class _Dom>
    inline
    valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
    : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
    { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); }

  template<typename _Tp>
    inline
    valarray<_Tp>::~valarray()
    {
      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
      std::__valarray_release_memory(_M_data);
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const valarray<_Tp>& __v)
    {
      ;
      std::__valarray_copy(__v._M_data, _M_size, _M_data);
      return *this;
    }
# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const _Tp& __t)
    {
      std::__valarray_fill(_M_data, _M_size, __t);
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
    {
      ;
      std::__valarray_copy(__sa._M_array, __sa._M_sz,
      __sa._M_stride, _Array<_Tp>(_M_data));
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
    {
      ;
      std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
      _Array<_Tp>(_M_data), _M_size);
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
    {
      ;
      std::__valarray_copy(__ma._M_array, __ma._M_mask,
      _Array<_Tp>(_M_data), _M_size);
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
    {
      ;
      std::__valarray_copy(__ia._M_array, __ia._M_index,
      _Array<_Tp>(_M_data), _M_size);
      return *this;
    }

  template<typename _Tp> template<class _Dom>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
    {
      ;
      std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
      return *this;
    }

  template<typename _Tp>
    inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
    valarray<_Tp>::operator[](slice __s) const
    {
      typedef _SClos<_ValArray,_Tp> _Closure;
      return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
    }

  template<typename _Tp>
    inline slice_array<_Tp>
    valarray<_Tp>::operator[](slice __s)
    { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); }

  template<typename _Tp>
    inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
    valarray<_Tp>::operator[](const gslice& __gs) const
    {
      typedef _GClos<_ValArray,_Tp> _Closure;
      return _Expr<_Closure, _Tp>
 (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
    }

  template<typename _Tp>
    inline gslice_array<_Tp>
    valarray<_Tp>::operator[](const gslice& __gs)
    {
      return gslice_array<_Tp>
 (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
    }

  template<typename _Tp>
    inline valarray<_Tp>
    valarray<_Tp>::operator[](const valarray<bool>& __m) const
    {
      size_t __s = 0;
      size_t __e = __m.size();
      for (size_t __i=0; __i<__e; ++__i)
 if (__m[__i]) ++__s;
      return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
        _Array<bool> (__m)));
    }

  template<typename _Tp>
    inline mask_array<_Tp>
    valarray<_Tp>::operator[](const valarray<bool>& __m)
    {
      size_t __s = 0;
      size_t __e = __m.size();
      for (size_t __i=0; __i<__e; ++__i)
 if (__m[__i]) ++__s;
      return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m));
    }

  template<typename _Tp>
    inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
    valarray<_Tp>::operator[](const valarray<size_t>& __i) const
    {
      typedef _IClos<_ValArray,_Tp> _Closure;
      return _Expr<_Closure, _Tp>(_Closure(*this, __i));
    }

  template<typename _Tp>
    inline indirect_array<_Tp>
    valarray<_Tp>::operator[](const valarray<size_t>& __i)
    {
      return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
     _Array<size_t>(__i));
    }

  template<class _Tp>
    inline size_t
    valarray<_Tp>::size() const
    { return _M_size; }

  template<class _Tp>
    inline _Tp
    valarray<_Tp>::sum() const
    {
      ;
      return std::__valarray_sum(_M_data, _M_data + _M_size);
    }

  template<class _Tp>
     inline valarray<_Tp>
     valarray<_Tp>::shift(int __n) const
     {
       valarray<_Tp> __ret;

       if (_M_size == 0)
  return __ret;

       _Tp* __restrict__ __tmp_M_data =
  std::__valarray_get_storage<_Tp>(_M_size);

       if (__n == 0)
  std::__valarray_copy_construct(_M_data,
     _M_data + _M_size, __tmp_M_data);
       else if (__n > 0)
  {
    if (size_t(__n) > _M_size)
      __n = int(_M_size);

    std::__valarray_copy_construct(_M_data + __n,
       _M_data + _M_size, __tmp_M_data);
    std::__valarray_default_construct(__tmp_M_data + _M_size - __n,
          __tmp_M_data + _M_size);
  }
       else
  {
    if (-size_t(__n) > _M_size)
      __n = -int(_M_size);

    std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
       __tmp_M_data - __n);
    std::__valarray_default_construct(__tmp_M_data,
          __tmp_M_data - __n);
  }

       __ret._M_size = _M_size;
       __ret._M_data = __tmp_M_data;
       return __ret;
     }

  template<class _Tp>
     inline valarray<_Tp>
     valarray<_Tp>::cshift(int __n) const
     {
       valarray<_Tp> __ret;

       if (_M_size == 0)
  return __ret;

       _Tp* __restrict__ __tmp_M_data =
  std::__valarray_get_storage<_Tp>(_M_size);

       if (__n == 0)
  std::__valarray_copy_construct(_M_data,
     _M_data + _M_size, __tmp_M_data);
       else if (__n > 0)
  {
    if (size_t(__n) > _M_size)
      __n = int(__n % _M_size);

    std::__valarray_copy_construct(_M_data, _M_data + __n,
       __tmp_M_data + _M_size - __n);
    std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size,
       __tmp_M_data);
  }
       else
  {
    if (-size_t(__n) > _M_size)
      __n = -int(-size_t(__n) % _M_size);

    std::__valarray_copy_construct(_M_data + _M_size + __n,
       _M_data + _M_size, __tmp_M_data);
    std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
       __tmp_M_data - __n);
  }

       __ret._M_size = _M_size;
       __ret._M_data = __tmp_M_data;
       return __ret;
     }

  template<class _Tp>
    inline void
    valarray<_Tp>::resize(size_t __n, _Tp __c)
    {



      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
      if (_M_size != __n)
 {
   std::__valarray_release_memory(_M_data);
   _M_size = __n;
   _M_data = __valarray_get_storage<_Tp>(__n);
 }
      std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
    }

  template<typename _Tp>
    inline _Tp
    valarray<_Tp>::min() const
    {
      ;
      return *std::min_element(_M_data, _M_data + _M_size);
    }

  template<typename _Tp>
    inline _Tp
    valarray<_Tp>::max() const
    {
      ;
      return *std::max_element(_M_data, _M_data + _M_size);
    }

  template<class _Tp>
    inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
    valarray<_Tp>::apply(_Tp func(_Tp)) const
    {
      typedef _ValFunClos<_ValArray, _Tp> _Closure;
      return _Expr<_Closure, _Tp>(_Closure(*this, func));
    }

  template<class _Tp>
    inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
    valarray<_Tp>::apply(_Tp func(const _Tp &)) const
    {
      typedef _RefFunClos<_ValArray, _Tp> _Closure;
      return _Expr<_Closure, _Tp>(_Closure(*this, func));
    }

#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op,_Name) template<typename _Tp> inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt valarray<_Tp>::operator _Op() const { typedef _UnClos<_Name, _ValArray, _Tp> _Closure; typedef typename __fun<_Name, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); }
# 968 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
    template<typename _Tp> inline typename valarray<_Tp>::template _UnaryOp<__unary_plus>::_Rt valarray<_Tp>::operator +() const { typedef _UnClos<__unary_plus, _ValArray, _Tp> _Closure; typedef typename __fun<__unary_plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); }
    template<typename _Tp> inline typename valarray<_Tp>::template _UnaryOp<__negate>::_Rt valarray<_Tp>::operator -() const { typedef _UnClos<__negate, _ValArray, _Tp> _Closure; typedef typename __fun<__negate, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); }
    template<typename _Tp> inline typename valarray<_Tp>::template _UnaryOp<__bitwise_not>::_Rt valarray<_Tp>::operator ~() const { typedef _UnClos<__bitwise_not, _ValArray, _Tp> _Closure; typedef typename __fun<__bitwise_not, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); }
    template<typename _Tp> inline typename valarray<_Tp>::template _UnaryOp<__logical_not>::_Rt valarray<_Tp>::operator !() const { typedef _UnClos<__logical_not, _ValArray, _Tp> _Closure; typedef typename __fun<__logical_not, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); }

#undef _DEFINE_VALARRAY_UNARY_OPERATOR

#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op,_Name) template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator _Op ##=(const _Tp &__t) { _Array_augmented_ ##_Name(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator _Op ##=(const valarray<_Tp> &__v) { _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); _Array_augmented_ ##_Name(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
# 994 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator +=(const _Tp &__t) { _Array_augmented___plus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator +=(const valarray<_Tp> &__v) { ; _Array_augmented___plus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator -=(const _Tp &__t) { _Array_augmented___minus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator -=(const valarray<_Tp> &__v) { ; _Array_augmented___minus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator *=(const _Tp &__t) { _Array_augmented___multiplies(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator *=(const valarray<_Tp> &__v) { ; _Array_augmented___multiplies(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator /=(const _Tp &__t) { _Array_augmented___divides(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator /=(const valarray<_Tp> &__v) { ; _Array_augmented___divides(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator %=(const _Tp &__t) { _Array_augmented___modulus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator %=(const valarray<_Tp> &__v) { ; _Array_augmented___modulus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator ^=(const _Tp &__t) { _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator ^=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator &=(const _Tp &__t) { _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator &=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator |=(const _Tp &__t) { _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator |=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator <<=(const _Tp &__t) { _Array_augmented___shift_left(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator <<=(const valarray<_Tp> &__v) { ; _Array_augmented___shift_left(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator >>=(const _Tp &__t) { _Array_augmented___shift_right(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template<class _Tp> inline valarray<_Tp>& valarray<_Tp>::operator >>=(const valarray<_Tp> &__v) { ; _Array_augmented___shift_right(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }

#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT

#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op,_Name) template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator _Op ##=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented_ ##_Name(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
# 1016 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator +=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___plus(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator -=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___minus(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator *=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___multiplies(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator /=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___divides(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator %=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___modulus(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator ^=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator &=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator |=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator <<=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___shift_left(_Array<_Tp>(_M_data), __e, _M_size); return *this; }
template<class _Tp> template<class _Dom> inline valarray<_Tp>& valarray<_Tp>::operator >>=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___shift_right(_Array<_Tp>(_M_data), __e, _M_size); return *this; }

#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT


#define _DEFINE_BINARY_OPERATOR(_Op,_Name) template<typename _Tp> inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<_Name, _Tp>::result_type> operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<_Name, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, typename __fun<_Name, _Tp>::result_type> operator _Op(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<_Name, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, typename __fun<_Name, _Tp>::result_type> operator _Op(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<_Name, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
# 1062 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/valarray" 3
template<typename _Tp> inline _Expr<_BinClos<__plus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__plus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__plus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__plus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__plus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__plus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__minus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__minus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__minus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__minus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__minus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__minus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__multiplies, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__multiplies, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__multiplies, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__multiplies, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__multiplies, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__multiplies, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__divides, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__divides, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__divides, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__divides, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__divides, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__divides, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__modulus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__modulus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__modulus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__modulus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__modulus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__modulus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__bitwise_xor, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_xor, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_xor, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__bitwise_xor, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_xor, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_xor, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__bitwise_and, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_and, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_and, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__bitwise_and, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_and, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_and, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__bitwise_or, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_or, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_or, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__bitwise_or, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__bitwise_or, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_or, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__shift_left, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__shift_left, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__shift_left, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__shift_left, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__shift_left, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__shift_left, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__shift_right, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__shift_right, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__shift_right, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__shift_right, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__shift_right, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__shift_right, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__logical_and, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__logical_and, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__logical_and, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__logical_and, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__logical_and, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__logical_and, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__logical_or, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__logical_or, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__logical_or, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__logical_or, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__logical_or, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__logical_or, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__equal_to, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__equal_to, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__equal_to, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__equal_to, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__equal_to, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__equal_to, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__not_equal_to, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__not_equal_to, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__not_equal_to, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__not_equal_to, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__not_equal_to, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__not_equal_to, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__less, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__less, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__less, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__less, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__less, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__less, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__greater, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__greater, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__greater, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__greater, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__greater, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__greater, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__less_equal, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__less_equal, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__less_equal, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__less_equal, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__less_equal, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__less_equal, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }
template<typename _Tp> inline _Expr<_BinClos<__greater_equal, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__greater_equal, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template<typename _Tp> inline _Expr<_BinClos<__greater_equal, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const valarray<_Tp>& __v, const _Tp& __t) { typedef _BinClos<__greater_equal, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template<typename _Tp> inline _Expr<_BinClos<__greater_equal, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const _Tp& __t, const valarray<_Tp>& __v) { typedef _BinClos<__greater_equal, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); }

#undef _DEFINE_BINARY_OPERATOR



}
# 25 "/usr/include/boost-1_41/boost/math/quaternion.hpp" 2



# 1 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp" 1
# 11 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp"
#define BOOST_SINC_HPP 






# 1 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 1






#define BOOST_MATH_TOOLS_CONFIG_HPP 





# 1 "/usr/include/boost-1_41/boost/cstdint.hpp" 1
# 24 "/usr/include/boost-1_41/boost/cstdint.hpp"
#define BOOST_CSTDINT_HPP 
# 42 "/usr/include/boost-1_41/boost/cstdint.hpp"
# 1 "/usr/include/stdint.h" 1 3 4
# 24 "/usr/include/stdint.h" 3 4
#define _STDINT_H 1



# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 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;
#define __uint32_t_defined 


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-1_41/boost/cstdint.hpp" 2
# 85 "/usr/include/boost-1_41/boost/cstdint.hpp"
namespace boost
{

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

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

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



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



  using ::intmax_t;
  using ::uintmax_t;

}
# 14 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4






#define _GCC_LIMITS_H_ 



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/syslimits.h" 1 3 4





#define _GCC_NEXT_LIMITS_H 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4
# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 25 "/usr/include/limits.h" 3 4
#define _LIBC_LIMITS_H_ 1







#define MB_LEN_MAX 16
# 133 "/usr/include/limits.h" 3 4
#define LLONG_MIN (-LLONG_MAX-1)


#define LLONG_MAX __LONG_LONG_MAX__


#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)





# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 26 "/usr/include/bits/posix1_lim.h" 3 4
#define _BITS_POSIX1_LIM_H 1





#define _POSIX_AIO_LISTIO_MAX 2


#define _POSIX_AIO_MAX 1


#define _POSIX_ARG_MAX 4096



#define _POSIX_CHILD_MAX 25





#define _POSIX_DELAYTIMER_MAX 32



#define _POSIX_HOST_NAME_MAX 255


#define _POSIX_LINK_MAX 8


#define _POSIX_LOGIN_NAME_MAX 9


#define _POSIX_MAX_CANON 255



#define _POSIX_MAX_INPUT 255


#define _POSIX_MQ_OPEN_MAX 8


#define _POSIX_MQ_PRIO_MAX 32


#define _POSIX_NAME_MAX 14



#define _POSIX_NGROUPS_MAX 8






#define _POSIX_OPEN_MAX 20







#define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX



#define _POSIX_PATH_MAX 256


#define _POSIX_PIPE_BUF 512



#define _POSIX_RE_DUP_MAX 255


#define _POSIX_RTSIG_MAX 8


#define _POSIX_SEM_NSEMS_MAX 256


#define _POSIX_SEM_VALUE_MAX 32767


#define _POSIX_SIGQUEUE_MAX 32


#define _POSIX_SSIZE_MAX 32767


#define _POSIX_STREAM_MAX 8


#define _POSIX_SYMLINK_MAX 255



#define _POSIX_SYMLOOP_MAX 8


#define _POSIX_TIMER_MAX 32


#define _POSIX_TTY_NAME_MAX 9


#define _POSIX_TZNAME_MAX 6



#define _POSIX_QLIMIT 1



#define _POSIX_HIWAT _POSIX_PIPE_BUF


#define _POSIX_UIO_MAXIOV 16



#define _POSIX_CLOCKRES_MIN 20000000



# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 26 "/usr/include/bits/local_lim.h" 3 4
#define __undef_NR_OPEN 


#define __undef_LINK_MAX 


#define __undef_OPEN_MAX 


#define __undef_ARG_MAX 



# 1 "/usr/include/linux/limits.h" 1 3 4

#define _LINUX_LIMITS_H 

#define NR_OPEN 1024

#define NGROUPS_MAX 65536
#define ARG_MAX 131072
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4096
#define PIPE_BUF 4096
#define XATTR_NAME_MAX 255
#define XATTR_SIZE_MAX 65536
#define XATTR_LIST_MAX 65536

#define RTSIG_MAX 32
# 40 "/usr/include/bits/local_lim.h" 2 3 4



#undef NR_OPEN
#undef __undef_NR_OPEN



#undef LINK_MAX
#undef __undef_LINK_MAX



#undef OPEN_MAX
#undef __undef_OPEN_MAX



#undef ARG_MAX
#undef __undef_ARG_MAX



#define _POSIX_THREAD_KEYS_MAX 128

#define PTHREAD_KEYS_MAX 1024


#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4

#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS


#define _POSIX_THREAD_THREADS_MAX 64

#undef PTHREAD_THREADS_MAX



#define AIO_PRIO_DELTA_MAX 20


#define PTHREAD_STACK_MIN 16384


#define DELAYTIMER_MAX 2147483647


#define TTY_NAME_MAX 32


#define LOGIN_NAME_MAX 256


#define HOST_NAME_MAX 64


#define MQ_PRIO_MAX 32768


#define SEM_VALUE_MAX (2147483647)
# 158 "/usr/include/bits/posix1_lim.h" 2 3 4



#define SSIZE_MAX LONG_MAX
# 146 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 24 "/usr/include/bits/posix2_lim.h" 3 4
#define _BITS_POSIX2_LIM_H 1



#define _POSIX2_BC_BASE_MAX 99


#define _POSIX2_BC_DIM_MAX 2048


#define _POSIX2_BC_SCALE_MAX 99


#define _POSIX2_BC_STRING_MAX 1000



#define _POSIX2_COLL_WEIGHTS_MAX 2



#define _POSIX2_EXPR_NEST_MAX 32


#define _POSIX2_LINE_MAX 2048



#define _POSIX2_RE_DUP_MAX 255



#define _POSIX2_CHARCLASS_NAME_MAX 14







#define BC_BASE_MAX _POSIX2_BC_BASE_MAX


#define BC_DIM_MAX _POSIX2_BC_DIM_MAX


#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX


#define BC_STRING_MAX _POSIX2_BC_STRING_MAX


#define COLL_WEIGHTS_MAX 255


#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX


#define LINE_MAX _POSIX2_LINE_MAX


#define CHARCLASS_NAME_MAX 2048



#define RE_DUP_MAX (0x7fff)
# 150 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 31 "/usr/include/bits/xopen_lim.h" 3 4
#define _XOPEN_LIM_H 1

#define __need_IOV_MAX 
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 42 "/usr/include/bits/stdio_lim.h" 3 4
#define IOV_MAX 1024
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 66 "/usr/include/bits/xopen_lim.h" 3 4
#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV




#define NL_ARGMAX _POSIX_ARG_MAX


#define NL_LANGMAX _POSIX2_LINE_MAX


#define NL_MSGMAX INT_MAX



#define NL_NMAX INT_MAX


#define NL_SETMAX INT_MAX


#define NL_TEXTMAX INT_MAX


#define NZERO 20
# 110 "/usr/include/bits/xopen_lim.h" 3 4
#define WORD_BIT 32
# 133 "/usr/include/bits/xopen_lim.h" 3 4
#define LONG_BIT 64
# 154 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/syslimits.h" 2 3 4
#undef _GCC_NEXT_LIMITS_H
# 12 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 2 3 4


#define _LIMITS_H___ 


#undef CHAR_BIT
#define CHAR_BIT __CHAR_BIT__







#undef SCHAR_MIN
#define SCHAR_MIN (-SCHAR_MAX - 1)
#undef SCHAR_MAX
#define SCHAR_MAX __SCHAR_MAX__


#undef UCHAR_MAX



#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 3 4
#undef CHAR_MIN
#define CHAR_MIN SCHAR_MIN
#undef CHAR_MAX
#define CHAR_MAX SCHAR_MAX



#undef SHRT_MIN
#define SHRT_MIN (-SHRT_MAX - 1)
#undef SHRT_MAX
#define SHRT_MAX __SHRT_MAX__


#undef USHRT_MAX



#define USHRT_MAX (SHRT_MAX * 2 + 1)



#undef INT_MIN
#define INT_MIN (-INT_MAX - 1)
#undef INT_MAX
#define INT_MAX __INT_MAX__


#undef UINT_MAX
#define UINT_MAX (INT_MAX * 2U + 1U)



#undef LONG_MIN
#define LONG_MIN (-LONG_MAX - 1L)
#undef LONG_MAX
#define LONG_MAX __LONG_MAX__


#undef ULONG_MAX
#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
# 105 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 3 4
#undef LONG_LONG_MIN
#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)
#undef LONG_LONG_MAX
#define LONG_LONG_MAX __LONG_LONG_MAX__


#undef ULONG_LONG_MAX
#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 2 3


#define _GLIBCXX_CLIMITS 1
# 19 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 2




# 1 "/usr/include/boost-1_41/boost/math/tools/user.hpp" 1
# 10 "/usr/include/boost-1_41/boost/math/tools/user.hpp"
#define BOOST_MATH_TOOLS_USER_HPP 
# 24 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 2
# 1 "/usr/include/boost-1_41/boost/math/special_functions/detail/round_fwd.hpp" 1
# 9 "/usr/include/boost-1_41/boost/math/special_functions/detail/round_fwd.hpp"
#define BOOST_MATH_SPECIAL_ROUND_FWD_HPP 







namespace boost
{
   namespace math
   {

   template <class T, class Policy>
   T trunc(const T& v, const Policy& pol);
   template <class T>
   T trunc(const T& v);
   template <class T, class Policy>
   int itrunc(const T& v, const Policy& pol);
   template <class T>
   int itrunc(const T& v);
   template <class T, class Policy>
   long ltrunc(const T& v, const Policy& pol);
   template <class T>
   long ltrunc(const T& v);

   template <class T, class Policy>
   boost::long_long_type lltrunc(const T& v, const Policy& pol);
   template <class T>
   boost::long_long_type lltrunc(const T& v);

   template <class T, class Policy>
   T round(const T& v, const Policy& pol);
   template <class T>
   T round(const T& v);
   template <class T, class Policy>
   int iround(const T& v, const Policy& pol);
   template <class T>
   int iround(const T& v);
   template <class T, class Policy>
   long lround(const T& v, const Policy& pol);
   template <class T>
   long lround(const T& v);

   template <class T, class Policy>
   boost::long_long_type llround(const T& v, const Policy& pol);
   template <class T>
   boost::long_long_type llround(const T& v);

   template <class T, class Policy>
   T modf(const T& v, T* ipart, const Policy& pol);
   template <class T>
   T modf(const T& v, T* ipart);
   template <class T, class Policy>
   T modf(const T& v, int* ipart, const Policy& pol);
   template <class T>
   T modf(const T& v, int* ipart);
   template <class T, class Policy>
   T modf(const T& v, long* ipart, const Policy& pol);
   template <class T>
   T modf(const T& v, long* ipart);

   template <class T, class Policy>
   T modf(const T& v, boost::long_long_type* ipart, const Policy& pol);
   template <class T>
   T modf(const T& v, boost::long_long_type* ipart);


   }
}
# 25 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 2
# 90 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_USE_C99 
# 122 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(t) 
#define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
#define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
#define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 

#define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 
#define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
#define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
#define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 







#define BOOST_MATH_SMALL_CONSTANT(x) 0
# 161 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_POLY_METHOD 3
#define BOOST_MATH_RATIONAL_METHOD 3
#define BOOST_MATH_INT_TABLE_TYPE(RT,IT) RT
#define BOOST_MATH_INT_VALUE_SUFFIX(RV,SUF) RV ##.0L
# 177 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_MAX_POLY_ORDER 17
# 202 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_CONTROL_FP 




#define BOOST_MATH_STD_USING using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
# 240 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
namespace boost{ namespace math{
namespace tools
{

template <class T>
inline T max (T a, T b, T c)
{
   return (std::max)((std::max)(a, b), c);
}

template <class T>
inline T max (T a, T b, T c, T d)
{
   return (std::max)((std::max)(a, b), (std::max)(c, d));
}
}
}}



# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/fenv.h" 1 3
# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/fenv.h" 3
#define _GLIBCXX_FENV_H 1

       
# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/fenv.h" 3



# 1 "/usr/include/fenv.h" 1 3 4
# 24 "/usr/include/fenv.h" 3 4
#define _FENV_H 1
# 58 "/usr/include/fenv.h" 3 4
# 1 "/usr/include/bits/fenv.h" 1 3 4
# 23 "/usr/include/bits/fenv.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4



#define __WORDSIZE 64
#define __WORDSIZE_COMPAT32 1
# 24 "/usr/include/bits/fenv.h" 2 3 4




enum
  {
    FE_INVALID = 0x01,
#define FE_INVALID FE_INVALID
    __FE_DENORM = 0x02,
    FE_DIVBYZERO = 0x04,
#define FE_DIVBYZERO FE_DIVBYZERO
    FE_OVERFLOW = 0x08,
#define FE_OVERFLOW FE_OVERFLOW
    FE_UNDERFLOW = 0x10,
#define FE_UNDERFLOW FE_UNDERFLOW
    FE_INEXACT = 0x20
#define FE_INEXACT FE_INEXACT
  };

#define FE_ALL_EXCEPT (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)





enum
  {
    FE_TONEAREST = 0,
#define FE_TONEAREST FE_TONEAREST
    FE_DOWNWARD = 0x400,
#define FE_DOWNWARD FE_DOWNWARD
    FE_UPWARD = 0x800,
#define FE_UPWARD FE_UPWARD
    FE_TOWARDZERO = 0xc00
#define FE_TOWARDZERO FE_TOWARDZERO
  };



typedef unsigned short int fexcept_t;






typedef struct
  {
    unsigned short int __control_word;
    unsigned short int __unused1;
    unsigned short int __status_word;
    unsigned short int __unused2;
    unsigned short int __tags;
    unsigned short int __unused3;
    unsigned int __eip;
    unsigned short int __cs_selector;
    unsigned int __opcode:11;
    unsigned int __unused4:5;
    unsigned int __data_offset;
    unsigned short int __data_selector;
    unsigned short int __unused5;

    unsigned int __mxcsr;

  }
fenv_t;


#define FE_DFL_ENV ((__const fenv_t *) -1)



#define FE_NOMASK_ENV ((__const fenv_t *) -2)
# 59 "/usr/include/fenv.h" 2 3 4

extern "C" {




extern int feclearexcept (int __excepts) throw ();



extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw ();


extern int feraiseexcept (int __excepts) throw ();



extern int fesetexceptflag (__const fexcept_t *__flagp, int __excepts) throw ();



extern int fetestexcept (int __excepts) throw ();





extern int fegetround (void) throw ();


extern int fesetround (int __rounding_direction) throw ();






extern int fegetenv (fenv_t *__envp) throw ();




extern int feholdexcept (fenv_t *__envp) throw ();



extern int fesetenv (__const fenv_t *__envp) throw ();




extern int feupdateenv (__const fenv_t *__envp) throw ();
# 123 "/usr/include/fenv.h" 3 4
extern int feenableexcept (int __excepts) throw ();




extern int fedisableexcept (int __excepts) throw ();


extern int fegetexcept (void) throw ();


}
# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/fenv.h" 2 3
# 261 "/usr/include/boost-1_41/boost/math/tools/config.hpp" 2

   namespace boost{ namespace math{
   namespace detail
   {
   struct fpu_guard
   {
      fpu_guard()
      {
         fegetexceptflag(&m_flags, (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID));
         feclearexcept((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID));
      }
      ~fpu_guard()
      {
         fesetexceptflag(&m_flags, (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID));
      }
   private:
      fexcept_t m_flags;
   };

   }
   }}

#define BOOST_FPU_EXCEPTION_GUARD boost::math::detail::fpu_guard local_guard_object;
#define BOOST_MATH_INSTRUMENT_FPU do{ fexcept_t cpu_flags; fegetexceptflag(&cpu_flags, FE_ALL_EXCEPT); BOOST_MATH_INSTRUMENT_VARIABLE(cpu_flags); } while(0);
# 295 "/usr/include/boost-1_41/boost/math/tools/config.hpp"
#define BOOST_MATH_INSTRUMENT_CODE(x) 
#define BOOST_MATH_INSTRUMENT_VARIABLE(name) 
# 19 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp" 2
# 1 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 1






#define BOOST_MATH_TOOLS_PRECISION_INCLUDED 





# 1 "/usr/include/boost-1_41/boost/limits.hpp" 1
# 12 "/usr/include/boost-1_41/boost/limits.hpp"
#define BOOST_LIMITS 
# 14 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 2
# 1 "/usr/include/boost-1_41/boost/assert.hpp" 1
# 16 "/usr/include/boost-1_41/boost/assert.hpp"
#undef BOOST_ASSERT
# 36 "/usr/include/boost-1_41/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 37 "/usr/include/boost-1_41/boost/assert.hpp" 2
#define BOOST_ASSERT(expr) assert(expr)


#undef BOOST_VERIFY







#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# 15 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 2




# 1 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 1






#define BOOST_MATH_POLICY_HPP 

# 1 "/usr/include/boost-1_41/boost/mpl/list.hpp" 1


#define BOOST_MPL_LIST_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/list.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/limits/list.hpp" 1


#define BOOST_MPL_LIMITS_LIST_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/limits/list.hpp"
#define BOOST_MPL_LIMIT_LIST_SIZE 20
# 19 "/usr/include/boost-1_41/boost/mpl/list.hpp" 2
# 27 "/usr/include/boost-1_41/boost/mpl/list.hpp"
#define AUX778076_LIST_HEADER BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE).hpp
# 36 "/usr/include/boost-1_41/boost/mpl/list.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/list20.hpp" 1


#define BOOST_MPL_LIST_LIST20_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/list/list20.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/list10.hpp" 1


#define BOOST_MPL_LIST_LIST10_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/list/list10.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 1


#define BOOST_MPL_LIST_LIST0_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/push_front.hpp" 1


#define BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/list/aux_/push_front.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/item.hpp" 1


#define BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/list/aux_/item.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/tag.hpp" 1


#define BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/list/aux_/tag.hpp"
namespace boost { namespace mpl { namespace aux {

struct list_tag;
struct l_iter_tag;

}}}
# 19 "/usr/include/boost-1_41/boost/mpl/list/aux_/item.hpp" 2



namespace boost { namespace mpl {

template<
      typename Size
    , typename T
    , typename Next
    >
struct l_item
{




    typedef aux::list_tag tag;
    typedef l_item type;

    typedef Size size;
    typedef T item;
    typedef Next next;
};

struct l_end
{



    typedef aux::list_tag tag;
    typedef l_end type;
    typedef long_<0> size;
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/list/aux_/push_front.hpp" 2


namespace boost { namespace mpl {

template<>
struct push_front_impl< aux::list_tag >
{
    template< typename List, typename T > struct apply
    {
        typedef l_item<
              typename next<typename List::size>::type
            , T
            , typename List::type
            > type;
    };
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/pop_front.hpp" 1


#define BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/pop_front.hpp"
namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename mpl::next<List>::type type;
    };
};

}}
# 21 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/push_back.hpp" 1


#define BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/push_back.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct has_push_back_impl;

template<>
struct has_push_back_impl< aux::list_tag >
{
    template< typename Seq > struct apply
        : false_
    {
    };
};

}}
# 22 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/front.hpp" 1


#define BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/list/aux_/front.hpp"
namespace boost { namespace mpl {

template<>
struct front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename List::item type;
    };
};

}}
# 23 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/clear.hpp" 1


#define BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/clear.hpp"
namespace boost { namespace mpl {

template<>
struct clear_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef l_end type;
    };
};

}}
# 24 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/O1_size.hpp" 1


#define BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/list/aux_/O1_size.hpp"
namespace boost { namespace mpl {

template<>
struct O1_size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 25 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/size.hpp" 1


#define BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/list/aux_/size.hpp"
namespace boost { namespace mpl {

template<>
struct size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 26 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/empty.hpp" 1


#define BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/empty.hpp"
namespace boost { namespace mpl {

template<>
struct empty_impl< aux::list_tag >
{
    template< typename List > struct apply
        : not_<typename List::size>
    {
    };
};

}}
# 27 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/begin_end.hpp" 1


#define BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/list/aux_/begin_end.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/iterator.hpp" 1


#define BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/list/aux_/iterator.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_spec.hpp" 1


#define BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/aux_/lambda_spec.hpp"
#define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i,name) template< BOOST_MPL_PP_PARAMS(i, typename T) , typename Tag > struct lambda< name< BOOST_MPL_PP_PARAMS(i, T) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<i>) > { typedef false_ is_le; typedef name< BOOST_MPL_PP_PARAMS(i, T) > result_; typedef result_ type; };
# 23 "/usr/include/boost-1_41/boost/mpl/list/aux_/iterator.hpp" 2


namespace boost { namespace mpl {



template< typename Node >
struct l_iter
{
    typedef aux::l_iter_tag tag;
    typedef forward_iterator_tag category;
};

template< typename Node >
struct deref< l_iter<Node> >
{
    typedef typename Node::item type;
};

template< typename Node >
struct next< l_iter<Node> >
{
    typedef l_iter< typename Node::next > type;
};
# 62 "/usr/include/boost-1_41/boost/mpl/list/aux_/iterator.hpp"
template<> struct l_iter<l_end>
{
    typedef aux::l_iter_tag tag;
    typedef forward_iterator_tag category;




};

template< typename T1 , typename Tag > struct lambda< l_iter< T1 > , Tag , int_<1> > { typedef false_ is_le; typedef l_iter< T1 > result_; typedef result_ type; };

}}
# 19 "/usr/include/boost-1_41/boost/mpl/list/aux_/begin_end.hpp" 2



namespace boost { namespace mpl {

template<>
struct begin_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef l_iter<typename List::type> type;
    };
};

template<>
struct end_impl< aux::list_tag >
{
    template< typename > struct apply
    {
        typedef l_iter<l_end> type;
    };
};

}}
# 28 "/usr/include/boost-1_41/boost/mpl/list/list0.hpp" 2


namespace boost { namespace mpl {

template< typename Dummy = na > struct list0;

template<> struct list0<na>
    : l_end
{
    typedef l_end type;
};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/list/list10.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER list10.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp" 1
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp"
#define AUX778076_HEADER aux_/preprocessed/plain/BOOST_MPL_PREPROCESSED_HEADER
# 30 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/preprocessed/plain/list10.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/list/aux_/preprocessed/plain/list10.hpp"
namespace boost { namespace mpl {

template<
      typename T0
    >
struct list1
    : l_item<
          long_<1>
        , T0
        , l_end
        >
{
    typedef list1 type;
};

template<
      typename T0, typename T1
    >
struct list2
    : l_item<
          long_<2>
        , T0
        , list1<T1>
        >
{
    typedef list2 type;
};

template<
      typename T0, typename T1, typename T2
    >
struct list3
    : l_item<
          long_<3>
        , T0
        , list2< T1,T2 >
        >
{
    typedef list3 type;
};

template<
      typename T0, typename T1, typename T2, typename T3
    >
struct list4
    : l_item<
          long_<4>
        , T0
        , list3< T1,T2,T3 >
        >
{
    typedef list4 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    >
struct list5
    : l_item<
          long_<5>
        , T0
        , list4< T1,T2,T3,T4 >
        >
{
    typedef list5 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct list6
    : l_item<
          long_<6>
        , T0
        , list5< T1,T2,T3,T4,T5 >
        >
{
    typedef list6 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6
    >
struct list7
    : l_item<
          long_<7>
        , T0
        , list6< T1,T2,T3,T4,T5,T6 >
        >
{
    typedef list7 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7
    >
struct list8
    : l_item<
          long_<8>
        , T0
        , list7< T1,T2,T3,T4,T5,T6,T7 >
        >
{
    typedef list8 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8
    >
struct list9
    : l_item<
          long_<9>
        , T0
        , list8< T1,T2,T3,T4,T5,T6,T7,T8 >
        >
{
    typedef list9 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    >
struct list10
    : l_item<
          long_<10>
        , T0
        , list9< T1,T2,T3,T4,T5,T6,T7,T8,T9 >
        >
{
    typedef list10 type;
};

}}
# 31 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp" 2


#undef AUX778076_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 28 "/usr/include/boost-1_41/boost/mpl/list/list10.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/list/list20.hpp" 2







#define BOOST_MPL_PREPROCESSED_HEADER list20.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp" 1
# 21 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp"
#define AUX778076_HEADER aux_/preprocessed/plain/BOOST_MPL_PREPROCESSED_HEADER
# 30 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/list/aux_/preprocessed/plain/list20.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/list/aux_/preprocessed/plain/list20.hpp"
namespace boost { namespace mpl {

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10
    >
struct list11
    : l_item<
          long_<11>
        , T0
        , list10< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
        >
{
    typedef list11 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11
    >
struct list12
    : l_item<
          long_<12>
        , T0
        , list11< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
        >
{
    typedef list12 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12
    >
struct list13
    : l_item<
          long_<13>
        , T0
        , list12< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
        >
{
    typedef list13 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13
    >
struct list14
    : l_item<
          long_<14>
        , T0
        , list13< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
        >
{
    typedef list14 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    >
struct list15
    : l_item<
          long_<15>
        , T0
        , list14< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
        >
{
    typedef list15 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15
    >
struct list16
    : l_item<
          long_<16>
        , T0
        , list15< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
        >
{
    typedef list16 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16
    >
struct list17
    : l_item<
          long_<17>
        , T0
        , list16< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
        >
{
    typedef list17 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17
    >
struct list18
    : l_item<
          long_<18>
        , T0
        , list17< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
        >
{
    typedef list18 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18
    >
struct list19
    : l_item<
          long_<19>
        , T0
        , list18< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
        >
{
    typedef list19 type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18, typename T19
    >
struct list20
    : l_item<
          long_<20>
        , T0
        , list19< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >
        >
{
    typedef list20 type;
};

}}
# 31 "/usr/include/boost-1_41/boost/mpl/list/aux_/include_preprocessed.hpp" 2


#undef AUX778076_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 28 "/usr/include/boost-1_41/boost/mpl/list/list20.hpp" 2
# 37 "/usr/include/boost-1_41/boost/mpl/list.hpp" 2
#undef AUX778076_LIST_HEADER







#define BOOST_MPL_PREPROCESSED_HEADER list.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/list.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/list.hpp"
namespace boost { namespace mpl {

template<
      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
    , typename T12 = na, typename T13 = na, typename T14 = na
    , typename T15 = na, typename T16 = na, typename T17 = na
    , typename T18 = na, typename T19 = na
    >
struct list;

template<

    >
struct list<
          na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list0< >
{
    typedef list0< >::type type;
};

template<
      typename T0
    >
struct list<
          T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list1<T0>
{
    typedef typename list1<T0>::type type;
};

template<
      typename T0, typename T1
    >
struct list<
          T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list2< T0,T1 >
{
    typedef typename list2< T0,T1 >::type type;
};

template<
      typename T0, typename T1, typename T2
    >
struct list<
          T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list3< T0,T1,T2 >
{
    typedef typename list3< T0,T1,T2 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3
    >
struct list<
          T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list4< T0,T1,T2,T3 >
{
    typedef typename list4< T0,T1,T2,T3 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    >
struct list<
          T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list5< T0,T1,T2,T3,T4 >
{
    typedef typename list5< T0,T1,T2,T3,T4 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct list<
          T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list6< T0,T1,T2,T3,T4,T5 >
{
    typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list7< T0,T1,T2,T3,T4,T5,T6 >
{
    typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list8< T0,T1,T2,T3,T4,T5,T6,T7 >
{
    typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
{
    typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
        , na, na, na
        >
    : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
{
    typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
        , na, na, na
        >
    : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
{
    typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
        , na, na, na, na
        >
    : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
{
    typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
        , na, na, na, na
        >
    : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
{
    typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
        , na, na, na, na
        >
    : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
{
    typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
        , na, na, na, na
        >
    : list15<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        >
{
    typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, na, na, na, na
        >
    : list16<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15
        >
{
    typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, na, na, na
        >
    : list17<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16
        >
{
    typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, na, na
        >
    : list18<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17
        >
{
    typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18
    >
struct list<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18, na
        >
    : list19<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18
        >
{
    typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
};



template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18, typename T19
    >
struct list
    : list20<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18, T19
        >
{
    typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 47 "/usr/include/boost-1_41/boost/mpl/list.hpp" 2
# 10 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/contains.hpp" 1


#define BOOST_MPL_CONTAINS_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/contains.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/contains_fwd.hpp" 1


#define BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/contains_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct contains_impl;
template< typename Sequence, typename T > struct contains;

}}
# 19 "/usr/include/boost-1_41/boost/mpl/contains.hpp" 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/contains_impl.hpp" 1


#define BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/contains_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/find.hpp" 1


#define BOOST_MPL_FIND_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/find.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/find_if.hpp" 1


#define BOOST_MPL_FIND_IF_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/find_if.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/find_if_pred.hpp" 1


#define BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED 
# 14 "/usr/include/boost-1_41/boost/mpl/aux_/find_if_pred.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/iter_apply.hpp" 1


#define BOOST_MPL_ITER_APPLY_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/aux_/iter_apply.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/iter_apply.hpp" 2


namespace boost { namespace mpl { namespace aux {

template<
      typename F
    , typename Iterator
    >
struct iter_apply1
    : apply1< F,typename deref<Iterator>::type >
{
};

template<
      typename F
    , typename Iterator1
    , typename Iterator2
    >
struct iter_apply2
    : apply2<
          F
        , typename deref<Iterator1>::type
        , typename deref<Iterator2>::type
        >
{
};

}}}
# 15 "/usr/include/boost-1_41/boost/mpl/aux_/find_if_pred.hpp" 2


namespace boost { namespace mpl { namespace aux {

template< typename Predicate >
struct find_if_pred
{
    template< typename Iterator >
    struct apply
    {
        typedef not_< aux::iter_apply1<Predicate,Iterator> > type;
    };
};

}}}
# 18 "/usr/include/boost-1_41/boost/mpl/find_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 1
# 19 "/usr/include/boost-1_41/boost/mpl/find_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp" 1


#define BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/logical.hpp" 1


#define BOOST_MPL_LOGICAL_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/pair.hpp" 1


#define BOOST_MPL_PAIR_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/pair.hpp"
namespace boost { namespace mpl {

template<
      typename T1 = na
    , typename T2 = na
    >
struct pair
{
    typedef pair type;
    typedef T1 first;
    typedef T2 second;

   
};

template<
      typename P = na
    >
struct first
{

    typedef typename P::first type;



   
};

template<
      typename P = na
    >
struct second
{

    typedef typename P::second type;



   
};


template<> struct pair< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair< na , na > result_; typedef pair< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair< na , na > > : int_<-1> { }; }
template<> struct first< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : first< T1 > { }; }; template< typename Tag > struct lambda< first< na > , Tag , int_<-1> > { typedef false_ is_le; typedef first< na > result_; typedef first< na > type; }; namespace aux { template< typename T1 > struct template_arity< first< T1 > > : int_<1> { }; template<> struct template_arity< first< na > > : int_<-1> { }; }
template<> struct second< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : second< T1 > { }; }; template< typename Tag > struct lambda< second< na > , Tag , int_<-1> > { typedef false_ is_le; typedef second< na > result_; typedef second< na > type; }; namespace aux { template< typename T1 > struct template_arity< second< T1 > > : int_<1> { }; template<> struct template_arity< second< na > > : int_<-1> { }; }

}}
# 24 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_if_impl.hpp" 1


#define BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_if_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_if_impl.hpp" 2
# 31 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_if_impl.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER iter_fold_if_impl.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 1
# 13 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename Iterator, typename State >
struct iter_fold_if_null_step
{
    typedef State state;
    typedef Iterator iterator;
};

template< bool >
struct iter_fold_if_step_impl
{
    template<
          typename Iterator
        , typename State
        , typename StateOp
        , typename IteratorOp
        >
    struct result_
    {
        typedef typename apply2< StateOp,State,Iterator >::type state;
        typedef typename IteratorOp::type iterator;
    };
};

template<>
struct iter_fold_if_step_impl<false>
{
    template<
          typename Iterator
        , typename State
        , typename StateOp
        , typename IteratorOp
        >
    struct result_
    {
        typedef State state;
        typedef Iterator iterator;
    };
};

template<
      typename Iterator
    , typename State
    , typename ForwardOp
    , typename Predicate
    >
struct iter_fold_if_forward_step
{
    typedef typename apply2< Predicate,State,Iterator >::type not_last;
    typedef typename iter_fold_if_step_impl<
          not_last::value
        >::template result_< Iterator,State,ForwardOp, mpl::next<Iterator> > impl_;

    typedef typename impl_::state state;
    typedef typename impl_::iterator iterator;
};

template<
      typename Iterator
    , typename State
    , typename BackwardOp
    , typename Predicate
    >
struct iter_fold_if_backward_step
{
    typedef typename apply2< Predicate,State,Iterator >::type not_last;
    typedef typename iter_fold_if_step_impl<
          not_last::value
        >::template result_< Iterator,State,BackwardOp, identity<Iterator> > impl_;

    typedef typename impl_::state state;
    typedef typename impl_::iterator iterator;
};

template<
      typename Iterator
    , typename State
    , typename ForwardOp
    , typename ForwardPredicate
    , typename BackwardOp
    , typename BackwardPredicate
    >
struct iter_fold_if_impl
{
 private:
    typedef iter_fold_if_null_step< Iterator,State > forward_step0;
    typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1;
    typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2;
    typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3;
    typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4;


    typedef typename if_<
          typename forward_step4::not_last
        , iter_fold_if_impl<
              typename forward_step4::iterator
            , typename forward_step4::state
            , ForwardOp
            , ForwardPredicate
            , BackwardOp
            , BackwardPredicate
            >
        , iter_fold_if_null_step<
              typename forward_step4::iterator
            , typename forward_step4::state
            >
        >::type backward_step4;

    typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3;
    typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2;
    typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1;
    typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0;


 public:
    typedef typename backward_step0::state state;
    typedef typename backward_step4::iterator iterator;
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 33 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_if_impl.hpp" 2
# 26 "/usr/include/boost-1_41/boost/mpl/iter_fold_if.hpp" 2







namespace boost { namespace mpl {

namespace aux {

template< typename Predicate, typename LastIterator >
struct iter_fold_if_pred
{
    template< typename State, typename Iterator > struct apply

        : and_<
              not_< is_same<Iterator,LastIterator> >
            , apply1<Predicate,Iterator>
            >
    {







    };
};

}

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    , typename ForwardPredicate = na
    , typename BackwardOp = na
    , typename BackwardPredicate = na
    >
struct iter_fold_if
{

    typedef typename begin<Sequence>::type first_;
    typedef typename end<Sequence>::type last_;

    typedef typename eval_if<
          is_na<BackwardPredicate>
        , if_< is_na<BackwardOp>, always<false_>, always<true_> >
        , identity<BackwardPredicate>
        >::type backward_pred_;



    struct result_ :



        aux::iter_fold_if_impl<
          first_
        , State
        , ForwardOp
        , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > >
        , BackwardOp
        , backward_pred_
        >

    { };




public:

    typedef pair<
          typename result_::state
        , typename result_::iterator
        > type;

   




};

template<> struct iter_fold_if< na , na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct apply : iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > { }; }; template< typename Tag > struct lambda< iter_fold_if< na , na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold_if< na , na , na , na , na , na > result_; typedef iter_fold_if< na , na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > > : int_<6> { }; template<> struct template_arity< iter_fold_if< na , na , na , na , na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/find_if.hpp" 2




namespace boost { namespace mpl {



template<
      typename Sequence = na
    , typename Predicate = na
    >
struct find_if
{
    typedef typename iter_fold_if<
          Sequence
        , void
        , mpl::arg<1>
        , protect< aux::find_if_pred<Predicate> >
        >::type result_;

    typedef typename second<result_>::type type;

   
};

template<> struct find_if< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find_if< T1 , T2 > { }; }; template< typename Tag > struct lambda< find_if< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find_if< na , na > result_; typedef find_if< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find_if< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find_if< na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_41/boost/mpl/find.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/same_as.hpp" 1


#define BOOST_MPL_SAME_AS_HPP_INCLUDED 
# 23 "/usr/include/boost-1_41/boost/mpl/same_as.hpp"
namespace boost { namespace mpl {

template< typename T1 >
struct same_as
{
    template< typename T2 > struct apply

        : is_same<T1,T2>
    {




    };
};

template< typename T1 >
struct not_same_as
{
    template< typename T2 > struct apply

        : not_< is_same<T1,T2> >
    {




    };
};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/find.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct find
    : find_if< Sequence,same_as<T> >
{
   
};

template<> struct find< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find< T1 , T2 > { }; }; template< typename Tag > struct lambda< find< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find< na , na > result_; typedef find< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find< na , na > > : int_<-1> { }; }

}}
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/contains_impl.hpp" 2







namespace boost { namespace mpl {

template< typename Tag >
struct contains_impl
{
    template< typename Sequence, typename T > struct apply

        : not_< is_same<
              typename find<Sequence,T>::type
            , typename end<Sequence>::type
            > >
    {
# 54 "/usr/include/boost-1_41/boost/mpl/aux_/contains_impl.hpp"
    };
};

 template<> struct contains_impl<non_sequence_tag> {};

}}
# 21 "/usr/include/boost-1_41/boost/mpl/contains.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct contains
    : contains_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};

template<> struct contains< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : contains< T1 , T2 > { }; }; template< typename Tag > struct lambda< contains< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef contains< na , na > result_; typedef contains< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< contains< T1 , T2 > > : int_<2> { }; template<> struct template_arity< contains< na , na > > : int_<-1> { }; }

}}
# 11 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp" 1


#define BOOST_MPL_REMOVE_IF_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/fold.hpp" 1


#define BOOST_MPL_FOLD_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/fold.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/O1_size.hpp" 1


#define BOOST_MPL_O1_SIZE_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/O1_size.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp" 1


#define BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/has_size.hpp" 1


#define BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/has_size.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp" 2





namespace boost { namespace mpl {
# 35 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp"
namespace aux {
template< typename Sequence > struct O1_size_impl
    : Sequence::size
{
};
}

template< typename Tag >
struct O1_size_impl
{
    template< typename Sequence > struct apply

        : if_<
              aux::has_size<Sequence>
            , aux::O1_size_impl<Sequence>
            , long_<-1>
            >::type
    {
# 69 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp"
    };
};
# 85 "/usr/include/boost-1_41/boost/mpl/aux_/O1_size_impl.hpp"
}}
# 20 "/usr/include/boost-1_41/boost/mpl/O1_size.hpp" 2



namespace boost { namespace mpl {


template<
      typename Sequence = na
    >
struct O1_size
    : O1_size_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/fold.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/fold_impl.hpp" 1


#define BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/fold_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/fold_impl.hpp" 2
# 33 "/usr/include/boost-1_41/boost/mpl/aux_/fold_impl.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER fold_impl.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp"
namespace boost { namespace mpl { namespace aux {



template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< 0,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef state0 state;
    typedef iter0 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< 1,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef state1 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< 2,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef state2 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< 3,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef state3 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< 4,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp, state3, typename deref<iter3>::type >::type state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef state4 state;
    typedef iter4 iterator;
};

template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl
{
    typedef fold_impl<
          4
        , First
        , Last
        , State
        , ForwardOp
        > chunk_;

    typedef fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , typename chunk_::iterator
        , Last
        , typename chunk_::state
        , ForwardOp
        > res_;

    typedef typename res_::state state;
    typedef typename res_::iterator iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< -1,First,Last,State,ForwardOp >
    : fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2<ForwardOp,State, typename deref<First>::type>::type
        , ForwardOp
        >
{
};

template<
      typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl< -1,Last,Last,State,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 35 "/usr/include/boost-1_41/boost/mpl/aux_/fold_impl.hpp" 2
# 21 "/usr/include/boost-1_41/boost/mpl/fold.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    >
struct fold
{
    typedef typename aux::fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , ForwardOp
        >::state type;

   
};

template<> struct fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef fold< na , na , na > result_; typedef fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< fold< na , na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/reverse_fold.hpp" 1


#define BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/reverse_fold.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/arg.hpp" 1
# 21 "/usr/include/boost-1_41/boost/mpl/reverse_fold.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/reverse_fold_impl.hpp" 1


#define BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/reverse_fold_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/reverse_fold_impl.hpp" 2
# 34 "/usr/include/boost-1_41/boost/mpl/aux_/reverse_fold_impl.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER reverse_fold_impl.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp"
namespace boost { namespace mpl { namespace aux {



template<
      long N
    , typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef fwd_state0 bkwd_state0;
    typedef bkwd_state0 state;
    typedef iter0 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef fwd_state1 bkwd_state1;
    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
    typedef bkwd_state0 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef fwd_state2 bkwd_state2;
    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef fwd_state3 bkwd_state3;
    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef fwd_state4 bkwd_state4;
    typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef iter4 iterator;
};

template<
      long N
    , typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef reverse_fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , iter4
        , Last
        , fwd_state4
        , BackwardOp
        , ForwardOp
        > nested_chunk;

    typedef typename nested_chunk::state bkwd_state4;
    typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef typename nested_chunk::iterator iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp >
{
    typedef reverse_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2<ForwardOp,State, typename deref<First>::type>::type
        , BackwardOp
        , ForwardOp
        > nested_step;

    typedef typename apply2<
          BackwardOp
        , typename nested_step::state
        , typename deref<First>::type
        >::type state;

    typedef typename nested_step::iterator iterator;
};

template<
      typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/reverse_fold_impl.hpp" 2
# 22 "/usr/include/boost-1_41/boost/mpl/reverse_fold.hpp" 2


namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename BackwardOp = na
    , typename ForwardOp = arg<1>
    >
struct reverse_fold
{
    typedef typename aux::reverse_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , BackwardOp
        , ForwardOp
        >::state type;

   
};

template<> struct reverse_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_fold< na , na , na > result_; typedef reverse_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_fold< na , na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp" 2




# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 25 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp" 1


#define BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/back_inserter.hpp" 1


#define BOOST_MPL_BACK_INSERTER_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/back_inserter.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/push_back.hpp" 1


#define BOOST_MPL_PUSH_BACK_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/push_back.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/push_back_impl.hpp" 1


#define BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/aux_/push_back_impl.hpp"
namespace boost { namespace mpl {

struct has_push_back_arg {};



template< typename Tag >
struct push_back_impl
{
    template< typename Sequence, typename T > struct apply
    {



        struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST44 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg44; enum { mpl_assertion_in_line_44 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_back_arg >::value ))>( mpl_assert_arg44::assert_arg() ) ) };




    };
};

template< typename Tag >
struct has_push_back_impl
{
    template< typename Seq > struct apply

        : aux::has_type< push_back< Seq, has_push_back_arg > >
    {







    };
};

 template<> struct push_back_impl<non_sequence_tag> {};
 template<> struct has_push_back_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/push_back.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct push_back
    : push_back_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};


template<
      typename Sequence = na
    >
struct has_push_back
    : has_push_back_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};


template<> struct push_back< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_back< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_back< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_back< na , na > result_; typedef push_back< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_back< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_back< na , na > > : int_<-1> { }; }
template<> struct has_push_back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_back< T1 > { }; }; template< typename Tag > struct lambda< has_push_back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_back< na > result_; typedef has_push_back< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_back< T1 > > : int_<1> { }; template<> struct template_arity< has_push_back< na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/back_inserter.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/inserter.hpp" 1


#define BOOST_MPL_INSERTER_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/inserter.hpp"
namespace boost { namespace mpl {

template<
      typename Sequence
    , typename Operation
    >
struct inserter
{
    typedef Sequence state;
    typedef Operation operation;
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/back_inserter.hpp" 2

namespace boost {
namespace mpl {

template<
      typename Sequence
    >
struct back_inserter
    : inserter< Sequence,push_back<> >
{
};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/front_inserter.hpp" 1


#define BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/front_inserter.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/push_front.hpp" 1


#define BOOST_MPL_PUSH_FRONT_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/push_front.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/push_front_impl.hpp" 1


#define BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED 
# 26 "/usr/include/boost-1_41/boost/mpl/aux_/push_front_impl.hpp"
namespace boost { namespace mpl {

struct has_push_front_arg {};




template< typename Tag >
struct push_front_impl
{
    template< typename Sequence, typename T > struct apply
    {



        struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST45 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg45; enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg45::assert_arg() ) ) };




    };
};

template< typename Tag >
struct has_push_front_impl
{
    template< typename Seq > struct apply

        : aux::has_type< push_front< Seq, has_push_front_arg > >
    {







    };
};

 template<> struct push_front_impl<non_sequence_tag> {};
 template<> struct has_push_front_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/push_front.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct push_front
    : push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};


template<
      typename Sequence = na
    >
struct has_push_front
    : has_push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/front_inserter.hpp" 2


namespace boost { namespace mpl {

template<
      typename Sequence
    >
struct front_inserter
    : inserter< Sequence,push_front<> >
{
};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp" 2




# 1 "/usr/include/boost-1_41/boost/mpl/clear.hpp" 1


#define BOOST_MPL_CLEAR_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/clear.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/clear_impl.hpp" 1


#define BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/aux_/clear_impl.hpp"
namespace boost { namespace mpl {



template< typename Tag >
struct clear_impl
{
    template< typename Sequence > struct apply;
};

 template<> struct clear_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost-1_41/boost/mpl/clear.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct clear
    : clear_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct clear< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : clear< T1 > { }; }; template< typename Tag > struct lambda< clear< na > , Tag , int_<-1> > { typedef false_ is_le; typedef clear< na > result_; typedef clear< na > type; }; namespace aux { template< typename T1 > struct template_arity< clear< T1 > > : int_<1> { }; template<> struct template_arity< clear< na > > : int_<-1> { }; }

}}
# 25 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp" 2






# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/default_params.hpp" 1


#define BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED 
# 51 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessor/default_params.hpp"
#define BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC(unused,i,pv) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2,0,pv), BOOST_PP_INC(i) ) = BOOST_PP_TUPLE_ELEM(2,1,pv)





#define BOOST_MPL_PP_DEFAULT_PARAMS(n,param,value) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC , (param,value) )
# 32 "/usr/include/boost-1_41/boost/mpl/aux_/inserter_algorithm.hpp" 2






#define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity,name) BOOST_MPL_AUX_COMMON_NAME_WKND(name) template< BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) > struct name : aux::name ##_impl<BOOST_MPL_PP_PARAMS(arity, P)> { }; template< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) > struct name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > : if_< has_push_back< typename clear<P1>::type> , aux::name ##_impl< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) , back_inserter< typename clear<P1>::type > > , aux::reverse_ ##name ##_impl< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) , front_inserter< typename clear<P1>::type > > >::type { }; template< BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) > struct reverse_ ##name : aux::reverse_ ##name ##_impl<BOOST_MPL_PP_PARAMS(arity, P)> { }; template< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) > struct reverse_ ##name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > : if_< has_push_back<P1> , aux::reverse_ ##name ##_impl< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) , back_inserter< typename clear<P1>::type > > , aux::name ##_impl< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) , front_inserter< typename clear<P1>::type > > >::type { }; BOOST_MPL_AUX_NA_SPEC(arity, name) BOOST_MPL_AUX_NA_SPEC(arity, reverse_ ##name)
# 26 "/usr/include/boost-1_41/boost/mpl/remove_if.hpp" 2

namespace boost { namespace mpl {

namespace aux {

template< typename Pred, typename InsertOp > struct remove_if_helper
{
    template< typename Sequence, typename U > struct apply
    {
        typedef typename eval_if<
              typename apply1<Pred,U>::type
            , identity<Sequence>
            , apply2<InsertOp,Sequence,U>
            >::type type;
    };
};

template<
      typename Sequence
    , typename Predicate
    , typename Inserter
    >
struct remove_if_impl
    : fold<
          Sequence
        , typename Inserter::state
        , protect< aux::remove_if_helper<
              typename lambda<Predicate>::type
            , typename Inserter::operation
            > >
        >
{
};

template<
      typename Sequence
    , typename Predicate
    , typename Inserter
    >
struct reverse_remove_if_impl
    : reverse_fold<
          Sequence
        , typename Inserter::state
        , protect< aux::remove_if_helper<
              typename lambda<Predicate>::type
            , typename Inserter::operation
            > >
        >
{
};

}

 template< typename P1 = na , typename P2 = na , typename P3 = na > struct remove_if : aux::remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct remove_if< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_remove_if : aux::reverse_remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_remove_if< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef remove_if< na , na , na > result_; typedef remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< remove_if< na , na , na > > : int_<-1> { }; } template<> struct reverse_remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_remove_if< na , na , na > result_; typedef reverse_remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_remove_if< na , na , na > > : int_<-1> { }; }

}}
# 14 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/vector.hpp" 1


#define BOOST_MPL_VECTOR_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/vector.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/limits/vector.hpp" 1


#define BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/limits/vector.hpp"
#define BOOST_MPL_LIMIT_VECTOR_SIZE 20
# 19 "/usr/include/boost-1_41/boost/mpl/vector.hpp" 2
# 27 "/usr/include/boost-1_41/boost/mpl/vector.hpp"
#define AUX778076_VECTOR_HEADER BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp
# 37 "/usr/include/boost-1_41/boost/mpl/vector.hpp"
#undef AUX778076_VECTOR_HEADER







#define BOOST_MPL_PREPROCESSED_HEADER vector.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/vector.hpp"
namespace boost { namespace mpl {

template<
      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
    , typename T12 = na, typename T13 = na, typename T14 = na
    , typename T15 = na, typename T16 = na, typename T17 = na
    , typename T18 = na, typename T19 = na
    >
struct vector;

template<

    >
struct vector<
          na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector0< >
{
    typedef vector0< >::type type;
};

template<
      typename T0
    >
struct vector<
          T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector1<T0>
{
    typedef typename vector1<T0>::type type;
};

template<
      typename T0, typename T1
    >
struct vector<
          T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector2< T0,T1 >
{
    typedef typename vector2< T0,T1 >::type type;
};

template<
      typename T0, typename T1, typename T2
    >
struct vector<
          T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector3< T0,T1,T2 >
{
    typedef typename vector3< T0,T1,T2 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3
    >
struct vector<
          T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector4< T0,T1,T2,T3 >
{
    typedef typename vector4< T0,T1,T2,T3 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    >
struct vector<
          T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector5< T0,T1,T2,T3,T4 >
{
    typedef typename vector5< T0,T1,T2,T3,T4 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct vector<
          T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector6< T0,T1,T2,T3,T4,T5 >
{
    typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector7< T0,T1,T2,T3,T4,T5,T6 >
{
    typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
{
    typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
{
    typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
        , na, na, na
        >
    : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
{
    typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
        , na, na, na
        >
    : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
{
    typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
        , na, na, na, na
        >
    : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
{
    typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
        , na, na, na, na
        >
    : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
{
    typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
        , na, na, na, na
        >
    : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
{
    typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
        , na, na, na, na
        >
    : vector15<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        >
{
    typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, na, na, na, na
        >
    : vector16<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15
        >
{
    typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, na, na, na
        >
    : vector17<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16
        >
{
    typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, na, na
        >
    : vector18<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17
        >
{
    typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
};

template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18
    >
struct vector<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18, na
        >
    : vector19<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18
        >
{
    typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
};



template<
      typename T0, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename T6, typename T7, typename T8, typename T9
    , typename T10, typename T11, typename T12, typename T13, typename T14
    , typename T15, typename T16, typename T17, typename T18, typename T19
    >
struct vector
    : vector20<
          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
        , T15, T16, T17, T18, T19
        >
{
    typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 47 "/usr/include/boost-1_41/boost/mpl/vector.hpp" 2
# 15 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/size.hpp" 1


#define BOOST_MPL_SIZE_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/size.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/size_impl.hpp" 1


#define BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/size_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/distance.hpp" 1


#define BOOST_MPL_DISTANCE_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/distance.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/iter_fold.hpp" 1


#define BOOST_MPL_ITER_FOLD_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/mpl/iter_fold.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_impl.hpp" 1


#define BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED 
# 19 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_impl.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply.hpp" 1
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 32 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_impl.hpp"
#define BOOST_MPL_PREPROCESSED_HEADER iter_fold_impl.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp"
namespace boost { namespace mpl { namespace aux {



template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 0,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef state0 state;
    typedef iter0 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 1,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef state1 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 2,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef state2 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 3,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef state3 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 4,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef state4 state;
    typedef iter4 iterator;
};

template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl
{
    typedef iter_fold_impl<
          4
        , First
        , Last
        , State
        , ForwardOp
        > chunk_;

    typedef iter_fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , typename chunk_::iterator
        , Last
        , typename chunk_::state
        , ForwardOp
        > res_;

    typedef typename res_::state state;
    typedef typename res_::iterator iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,First,Last,State,ForwardOp >
    : iter_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2< ForwardOp,State,First >::type
        , ForwardOp
        >
{
};

template<
      typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 34 "/usr/include/boost-1_41/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 22 "/usr/include/boost-1_41/boost/mpl/iter_fold.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    >
struct iter_fold
{
    typedef typename aux::iter_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , typename lambda<ForwardOp>::type
        >::state type;

   
};

template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost-1_41/boost/mpl/distance.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/iterator_range.hpp" 1


#define BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED 
# 20 "/usr/include/boost-1_41/boost/mpl/iterator_range.hpp"
namespace boost { namespace mpl {

struct iterator_range_tag;

template<
      typename First = na
    , typename Last = na
    >
struct iterator_range
{
    typedef iterator_range_tag tag;
    typedef iterator_range type;
    typedef First begin;
    typedef Last end;

   
};

template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/distance.hpp" 2



# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 24 "/usr/include/boost-1_41/boost/mpl/distance.hpp" 2







namespace boost { namespace mpl {


template< typename Tag > struct distance_impl
{
    template< typename First, typename Last > struct apply

        : aux::msvc_eti_base< typename iter_fold<
              iterator_range<First,Last>
            , mpl::long_<0>
            , next<>
            >::type >
    {
# 60 "/usr/include/boost-1_41/boost/mpl/distance.hpp"
    };
};

template<
      typename First = na
    , typename Last = na
    >
struct distance
    : distance_impl< typename tag<First>::type >
        ::template apply<First, Last>
{
   
};

template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost-1_41/boost/mpl/aux_/size_impl.hpp" 2



namespace boost { namespace mpl {




template< typename Tag >
struct size_impl
{
    template< typename Sequence > struct apply

        : distance<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {







    };
};

 template<> struct size_impl<non_sequence_tag> {};

}}
# 20 "/usr/include/boost-1_41/boost/mpl/size.hpp" 2




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct size
    : aux::msvc_eti_base<
        typename size_impl< typename sequence_tag<Sequence>::type >
            ::template apply< Sequence >::type
      >::type
{
   
};

template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/comparison.hpp" 1


#define BOOST_MPL_COMPARISON_HPP_INCLUDED 
# 18 "/usr/include/boost-1_41/boost/mpl/comparison.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/not_equal_to.hpp" 1


#define BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/not_equal_to.hpp"
#define AUX778076_OP_NAME not_equal_to
#define AUX778076_OP_TOKEN !=
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct not_equal_to_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct not_equal_to_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct not_equal_to_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct not_equal_to_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct not_equal_to_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct not_equal_to

    : not_equal_to_impl<
          typename not_equal_to_tag<N1>::type
        , typename not_equal_to_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct not_equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< not_equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_equal_to< na , na > result_; typedef not_equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< not_equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< not_equal_to< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct not_equal_to_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value != N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/not_equal_to.hpp" 2
# 19 "/usr/include/boost-1_41/boost/mpl/comparison.hpp" 2


# 1 "/usr/include/boost-1_41/boost/mpl/less_equal.hpp" 1


#define BOOST_MPL_LESS_EQUAL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/less_equal.hpp"
#define AUX778076_OP_NAME less_equal
#define AUX778076_OP_TOKEN <=
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct less_equal_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct less_equal_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_equal_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_equal_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct less_equal_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct less_equal

    : less_equal_impl<
          typename less_equal_tag<N1>::type
        , typename less_equal_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct less_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< less_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less_equal< na , na > result_; typedef less_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less_equal< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct less_equal_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value <= N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/less_equal.hpp" 2
# 22 "/usr/include/boost-1_41/boost/mpl/comparison.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mpl/greater_equal.hpp" 1


#define BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED 
# 17 "/usr/include/boost-1_41/boost/mpl/greater_equal.hpp"
#define AUX778076_OP_NAME greater_equal
#define AUX778076_OP_TOKEN >=
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#define AUX778076_OP_PREFIX AUX778076_OP_NAME


#define AUX778076_OP_ARITY 2

# 1 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/apply_wrap.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2






#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 1
# 23 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
# 37 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 1
# 12 "/usr/include/boost-1_41/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp"
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct greater_equal_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct greater_equal_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct greater_equal_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct greater_equal_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct greater_equal_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct greater_equal

    : greater_equal_impl<
          typename greater_equal_tag<N1>::type
        , typename greater_equal_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   

};

template<> struct greater_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater_equal< na , na > result_; typedef greater_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater_equal< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct greater_equal_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value >= N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost-1_41/boost/mpl/aux_/include_preprocessed.hpp" 2


#undef AUX778076_PREPROCESSED_HEADER

#undef BOOST_MPL_PREPROCESSED_HEADER
# 36 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp" 2
# 78 "/usr/include/boost-1_41/boost/mpl/aux_/comparison_op.hpp"
#undef AUX778076_OP_TAG_NAME
#undef AUX778076_OP_IMPL_NAME
#undef AUX778076_OP_ARITY
#undef AUX778076_OP_PREFIX
#undef AUX778076_OP_NAME
#undef AUX778076_OP_TOKEN
# 20 "/usr/include/boost-1_41/boost/mpl/greater_equal.hpp" 2
# 23 "/usr/include/boost-1_41/boost/mpl/comparison.hpp" 2
# 19 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2


# 1 "/usr/include/boost-1_41/boost/assert.hpp" 1
# 16 "/usr/include/boost-1_41/boost/assert.hpp"
#undef BOOST_ASSERT
# 36 "/usr/include/boost-1_41/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 37 "/usr/include/boost-1_41/boost/assert.hpp" 2
#define BOOST_ASSERT(expr) assert(expr)


#undef BOOST_VERIFY







#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# 22 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2




# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4
# 27 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 29 "/usr/include/boost-1_41/boost/math/policies/policy.hpp" 2


namespace boost{ namespace math{

namespace tools{

template <class T>
int digits();
template <class T>
T epsilon();

}

namespace policies{





#define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error


#define BOOST_MATH_POLE_ERROR_POLICY throw_on_error


#define BOOST_MATH_OVERFLOW_ERROR_POLICY throw_on_error


#define BOOST_MATH_EVALUATION_ERROR_POLICY throw_on_error


#define BOOST_MATH_ROUNDING_ERROR_POLICY throw_on_error


#define BOOST_MATH_UNDERFLOW_ERROR_POLICY ignore_error


#define BOOST_MATH_DENORM_ERROR_POLICY ignore_error


#define BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY ignore_error


#define BOOST_MATH_DIGITS10_POLICY 0


#define BOOST_MATH_PROMOTE_FLOAT_POLICY true





#define BOOST_MATH_PROMOTE_DOUBLE_POLICY true



#define BOOST_MATH_DISCRETE_QUANTILE_POLICY integer_round_outwards


#define BOOST_MATH_ASSERT_UNDEFINED_POLICY true


#define BOOST_MATH_MAX_SERIES_ITERATION_POLICY 1000000


#define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200




#define BOOST_MATH_META_INT(type,name,Default) template <type N = Default> struct name : public boost::mpl::int_<N>{}; namespace detail{ template <type N> char test_is_valid_arg(const name<N>*); char test_is_default_arg(const name<Default>*); template <class T> struct is_ ##name ##_imp { template <type N> static char test(const name<N>*); static double test(...); BOOST_STATIC_CONSTANT(bool, value = sizeof(test(static_cast<T*>(0))) == 1); }; } template <class T> struct is_ ##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_ ##name ##_imp<T>::value>{};
# 114 "/usr/include/boost-1_41/boost/math/policies/policy.hpp"
#define BOOST_MATH_META_BOOL(name,Default) template <bool N = Default> struct name : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const name<N>*); char test_is_default_arg(const name<Default>*); template <class T> struct is_ ##name ##_imp { template <bool N> static char test(const name<N>*); static double test(...); BOOST_STATIC_CONSTANT(bool, value = sizeof(test(static_cast<T*>(0))) == 1); }; } template <class T> struct is_ ##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_ ##name ##_imp<T>::value>{};
# 176 "/usr/include/boost-1_41/boost/math/policies/policy.hpp"
enum error_policy_type
{
   throw_on_error = 0,
   errno_on_error = 1,
   ignore_error = 2,
   user_error = 3
};

template <error_policy_type N = throw_on_error> struct domain_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const domain_error<N>*); char test_is_default_arg(const domain_error<throw_on_error>*); template <class T> struct is_domain_error_imp { template <error_policy_type N> static char test(const domain_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_domain_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_domain_error_imp<T>::value>{};
template <error_policy_type N = throw_on_error> struct pole_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const pole_error<N>*); char test_is_default_arg(const pole_error<throw_on_error>*); template <class T> struct is_pole_error_imp { template <error_policy_type N> static char test(const pole_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_pole_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_pole_error_imp<T>::value>{};
template <error_policy_type N = throw_on_error> struct overflow_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const overflow_error<N>*); char test_is_default_arg(const overflow_error<throw_on_error>*); template <class T> struct is_overflow_error_imp { template <error_policy_type N> static char test(const overflow_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_overflow_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_overflow_error_imp<T>::value>{};
template <error_policy_type N = ignore_error> struct underflow_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const underflow_error<N>*); char test_is_default_arg(const underflow_error<ignore_error>*); template <class T> struct is_underflow_error_imp { template <error_policy_type N> static char test(const underflow_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_underflow_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_underflow_error_imp<T>::value>{};
template <error_policy_type N = ignore_error> struct denorm_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const denorm_error<N>*); char test_is_default_arg(const denorm_error<ignore_error>*); template <class T> struct is_denorm_error_imp { template <error_policy_type N> static char test(const denorm_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_denorm_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_denorm_error_imp<T>::value>{};
template <error_policy_type N = throw_on_error> struct evaluation_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const evaluation_error<N>*); char test_is_default_arg(const evaluation_error<throw_on_error>*); template <class T> struct is_evaluation_error_imp { template <error_policy_type N> static char test(const evaluation_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_evaluation_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_evaluation_error_imp<T>::value>{};
template <error_policy_type N = throw_on_error> struct rounding_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const rounding_error<N>*); char test_is_default_arg(const rounding_error<throw_on_error>*); template <class T> struct is_rounding_error_imp { template <error_policy_type N> static char test(const rounding_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_rounding_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_rounding_error_imp<T>::value>{};
template <error_policy_type N = ignore_error> struct indeterminate_result_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const indeterminate_result_error<N>*); char test_is_default_arg(const indeterminate_result_error<ignore_error>*); template <class T> struct is_indeterminate_result_error_imp { template <error_policy_type N> static char test(const indeterminate_result_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_indeterminate_result_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_indeterminate_result_error_imp<T>::value>{};




template <bool N = true> struct promote_float : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const promote_float<N>*); char test_is_default_arg(const promote_float<true>*); template <class T> struct is_promote_float_imp { template <bool N> static char test(const promote_float<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_promote_float : public boost::mpl::bool_< ::boost::math::policies::detail::is_promote_float_imp<T>::value>{};
template <bool N = true> struct promote_double : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const promote_double<N>*); char test_is_default_arg(const promote_double<true>*); template <class T> struct is_promote_double_imp { template <bool N> static char test(const promote_double<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_promote_double : public boost::mpl::bool_< ::boost::math::policies::detail::is_promote_double_imp<T>::value>{};
template <bool N = true> struct assert_undefined : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const assert_undefined<N>*); char test_is_default_arg(const assert_undefined<true>*); template <class T> struct is_assert_undefined_imp { template <bool N> static char test(const assert_undefined<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_assert_undefined : public boost::mpl::bool_< ::boost::math::policies::detail::is_assert_undefined_imp<T>::value>{};



enum discrete_quantile_policy_type
{
   real,
   integer_round_outwards,
   integer_round_inwards,
   integer_round_down,
   integer_round_up,
   integer_round_nearest
};

template <discrete_quantile_policy_type N = integer_round_outwards> struct discrete_quantile : public boost::mpl::int_<N>{}; namespace detail{ template <discrete_quantile_policy_type N> char test_is_valid_arg(const discrete_quantile<N>*); char test_is_default_arg(const discrete_quantile<integer_round_outwards>*); template <class T> struct is_discrete_quantile_imp { template <discrete_quantile_policy_type N> static char test(const discrete_quantile<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_discrete_quantile : public boost::mpl::bool_< ::boost::math::policies::detail::is_discrete_quantile_imp<T>::value>{};



template <int N = 0> struct digits10 : public boost::mpl::int_<N>{}; namespace detail{ template <int N> char test_is_valid_arg(const digits10<N>*); char test_is_default_arg(const digits10<0>*); template <class T> struct is_digits10_imp { template <int N> static char test(const digits10<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_digits10 : public boost::mpl::bool_< ::boost::math::policies::detail::is_digits10_imp<T>::value>{};
template <int N = 0> struct digits2 : public boost::mpl::int_<N>{}; namespace detail{ template <int N> char test_is_valid_arg(const digits2<N>*); char test_is_default_arg(const digits2<0>*); template <class T> struct is_digits2_imp { template <int N> static char test(const digits2<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_digits2 : public boost::mpl::bool_< ::boost::math::policies::detail::is_digits2_imp<T>::value>{};



template <unsigned long N = 1000000> struct max_series_iterations : public boost::mpl::int_<N>{}; namespace detail{ template <unsigned long N> char test_is_valid_arg(const max_series_iterations<N>*); char test_is_default_arg(const max_series_iterations<1000000>*); template <class T> struct is_max_series_iterations_imp { template <unsigned long N> static char test(const max_series_iterations<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_max_series_iterations : public boost::mpl::bool_< ::boost::math::policies::detail::is_max_series_iterations_imp<T>::value>{};
template <unsigned long N = 200> struct max_root_iterations : public boost::mpl::int_<N>{}; namespace detail{ template <unsigned long N> char test_is_valid_arg(const max_root_iterations<N>*); char test_is_default_arg(const max_root_iterations<200>*); template <class T> struct is_max_root_iterations_imp { template <unsigned long N> static char test(const max_root_iterations<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_max_root_iterations : public boost::mpl::bool_< ::boost::math::policies::detail::is_max_root_iterations_imp<T>::value>{};



#define BOOST_MATH_PARAMETER(name) BOOST_PARAMETER_TEMPLATE_KEYWORD(name ##_name) BOOST_PARAMETER_NAME(name ##_name)



struct default_policy{};

namespace detail{



template <class Digits10, class Digits2>
struct precision
{



   typedef typename mpl::if_c<
      (Digits10::value == 0),
      digits2<0>,
      digits2<((Digits10::value + 1) * 1000L) / 301L>
   >::type digits2_type;
public:





   typedef typename mpl::if_c<
      (Digits2::value > digits2_type::value),
      Digits2, digits2_type>::type type;

};

template <class A, class B, bool b>
struct select_result
{
   typedef A type;
};
template <class A, class B>
struct select_result<A, B, false>
{
   typedef typename mpl::deref<B>::type type;
};

template <class Seq, class Pred, class DefaultType>
struct find_arg
{
private:
   typedef typename mpl::find_if<Seq, Pred>::type iter;
   typedef typename mpl::end<Seq>::type end_type;
public:
   typedef typename select_result<
      DefaultType, iter,
      ::boost::is_same<iter, end_type>::value>::type type;
};

double test_is_valid_arg(...);
double test_is_default_arg(...);
char test_is_valid_arg(const default_policy*);
char test_is_default_arg(const default_policy*);

template <class T>
struct is_valid_policy_imp
{
   static const bool value = sizeof(::boost::math::policies::detail::test_is_valid_arg(static_cast<T*>(0))) == 1;
};

template <class T>
struct is_default_policy_imp
{
   static const bool value = sizeof(::boost::math::policies::detail::test_is_default_arg(static_cast<T*>(0))) == 1;
};

template <class T> struct is_valid_policy
: public mpl::bool_<
   ::boost::math::policies::detail::is_valid_policy_imp<T>::value>
{};

template <class T> struct is_default_policy
: public mpl::bool_<
   ::boost::math::policies::detail::is_default_policy_imp<T>::value>
{
   template <class U>
   struct apply
   {
      typedef is_default_policy<U> type;
   };
};

template <class Seq, class T, int N>
struct append_N
{
   typedef typename mpl::push_back<Seq, T>::type new_seq;
   typedef typename append_N<new_seq, T, N-1>::type type;
};

template <class Seq, class T>
struct append_N<Seq, T, 0>
{
   typedef Seq type;
};





template <bool f, bool d>
struct default_args
{
   typedef promote_float<false> arg1;
   typedef promote_double<false> arg2;
};

template <>
struct default_args<false, false>
{
   typedef default_policy arg1;
   typedef default_policy arg2;
};

template <>
struct default_args<true, false>
{
   typedef promote_float<false> arg1;
   typedef default_policy arg2;
};

template <>
struct default_args<false, true>
{
   typedef promote_double<false> arg1;
   typedef default_policy arg2;
};

typedef default_args<true, true>::arg1 forwarding_arg1;
typedef default_args<true, true>::arg2 forwarding_arg2;

}




template <class A1 = default_policy,
          class A2 = default_policy,
          class A3 = default_policy,
          class A4 = default_policy,
          class A5 = default_policy,
          class A6 = default_policy,
          class A7 = default_policy,
          class A8 = default_policy,
          class A9 = default_policy,
          class A10 = default_policy,
          class A11 = default_policy,
          class A12 = default_policy,
          class A13 = default_policy>
struct policy
{
private:



   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A1>::value) == 0 ? false : true) >)> boost_static_assert_typedef_387;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A2>::value) == 0 ? false : true) >)> boost_static_assert_typedef_388;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A3>::value) == 0 ? false : true) >)> boost_static_assert_typedef_389;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A4>::value) == 0 ? false : true) >)> boost_static_assert_typedef_390;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A5>::value) == 0 ? false : true) >)> boost_static_assert_typedef_391;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A6>::value) == 0 ? false : true) >)> boost_static_assert_typedef_392;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A7>::value) == 0 ? false : true) >)> boost_static_assert_typedef_393;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A8>::value) == 0 ? false : true) >)> boost_static_assert_typedef_394;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A9>::value) == 0 ? false : true) >)> boost_static_assert_typedef_395;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A10>::value) == 0 ? false : true) >)> boost_static_assert_typedef_396;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A11>::value) == 0 ? false : true) >)> boost_static_assert_typedef_397;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A12>::value) == 0 ? false : true) >)> boost_static_assert_typedef_398;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A13>::value) == 0 ? false : true) >)> boost_static_assert_typedef_399;



   typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;

public:
   typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, domain_error<> >::type domain_error_type;
   typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, pole_error<> >::type pole_error_type;
   typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, overflow_error<> >::type overflow_error_type;
   typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, underflow_error<> >::type underflow_error_type;
   typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, denorm_error<> >::type denorm_error_type;
   typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, evaluation_error<> >::type evaluation_error_type;
   typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, rounding_error<> >::type rounding_error_type;
   typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, indeterminate_result_error<> >::type indeterminate_result_error_type;
private:



   typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
   typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, digits2<> >::type bits_precision_type;
public:
   typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;



   typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, promote_float<> >::type promote_float_type;
   typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, promote_double<> >::type promote_double_type;



   typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, discrete_quantile<> >::type discrete_quantile_type;



   typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;



   typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
   typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;
};





template <>
struct policy<default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
{
public:
   typedef domain_error<> domain_error_type;
   typedef pole_error<> pole_error_type;
   typedef overflow_error<> overflow_error_type;
   typedef underflow_error<> underflow_error_type;
   typedef denorm_error<> denorm_error_type;
   typedef evaluation_error<> evaluation_error_type;
   typedef rounding_error<> rounding_error_type;
   typedef indeterminate_result_error<> indeterminate_result_error_type;

   typedef digits2<> precision_type;



   typedef promote_float<> promote_float_type;
   typedef promote_double<> promote_double_type;
   typedef discrete_quantile<> discrete_quantile_type;
   typedef assert_undefined<> assert_undefined_type;
   typedef max_series_iterations<> max_series_iterations_type;
   typedef max_root_iterations<> max_root_iterations_type;
};

template <>
struct policy<detail::forwarding_arg1, detail::forwarding_arg2, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
{
public:
   typedef domain_error<> domain_error_type;
   typedef pole_error<> pole_error_type;
   typedef overflow_error<> overflow_error_type;
   typedef underflow_error<> underflow_error_type;
   typedef denorm_error<> denorm_error_type;
   typedef evaluation_error<> evaluation_error_type;
   typedef rounding_error<> rounding_error_type;
   typedef indeterminate_result_error<> indeterminate_result_error_type;

   typedef digits2<> precision_type;



   typedef promote_float<false> promote_float_type;
   typedef promote_double<false> promote_double_type;
   typedef discrete_quantile<> discrete_quantile_type;
   typedef assert_undefined<> assert_undefined_type;
   typedef max_series_iterations<> max_series_iterations_type;
   typedef max_root_iterations<> max_root_iterations_type;
};

template <class Policy,
          class A1 = default_policy,
          class A2 = default_policy,
          class A3 = default_policy,
          class A4 = default_policy,
          class A5 = default_policy,
          class A6 = default_policy,
          class A7 = default_policy,
          class A8 = default_policy,
          class A9 = default_policy,
          class A10 = default_policy,
          class A11 = default_policy,
          class A12 = default_policy,
          class A13 = default_policy>
struct normalise
{
private:
   typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;
   typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, typename Policy::domain_error_type >::type domain_error_type;
   typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, typename Policy::pole_error_type >::type pole_error_type;
   typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, typename Policy::overflow_error_type >::type overflow_error_type;
   typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, typename Policy::underflow_error_type >::type underflow_error_type;
   typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, typename Policy::denorm_error_type >::type denorm_error_type;
   typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, typename Policy::evaluation_error_type >::type evaluation_error_type;
   typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, typename Policy::rounding_error_type >::type rounding_error_type;
   typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, typename Policy::indeterminate_result_error_type >::type indeterminate_result_error_type;



   typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
   typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, typename Policy::precision_type >::type bits_precision_type;
   typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;



   typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, typename Policy::promote_float_type >::type promote_float_type;
   typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, typename Policy::promote_double_type >::type promote_double_type;



   typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, typename Policy::discrete_quantile_type >::type discrete_quantile_type;



   typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;



   typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
   typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;



   typedef mpl::vector<
      domain_error_type,
      pole_error_type,
      overflow_error_type,
      underflow_error_type,
      denorm_error_type,
      evaluation_error_type,
      rounding_error_type,
      indeterminate_result_error_type,
      precision_type,
      promote_float_type,
      promote_double_type,
      discrete_quantile_type,
      assert_undefined_type,
      max_series_iterations_type,
      max_root_iterations_type> result_list;



   typedef typename mpl::remove_if<result_list, detail::is_default_policy<mpl::_> >::type reduced_list;



   typedef typename detail::append_N<reduced_list, default_policy, (14 - ::boost::mpl::size<reduced_list>::value)>::type result_type;
public:
   typedef policy<
      typename mpl::at<result_type, mpl::int_<0> >::type,
      typename mpl::at<result_type, mpl::int_<1> >::type,
      typename mpl::at<result_type, mpl::int_<2> >::type,
      typename mpl::at<result_type, mpl::int_<3> >::type,
      typename mpl::at<result_type, mpl::int_<4> >::type,
      typename mpl::at<result_type, mpl::int_<5> >::type,
      typename mpl::at<result_type, mpl::int_<6> >::type,
      typename mpl::at<result_type, mpl::int_<7> >::type,
      typename mpl::at<result_type, mpl::int_<8> >::type,
      typename mpl::at<result_type, mpl::int_<9> >::type,
      typename mpl::at<result_type, mpl::int_<10> >::type,
      typename mpl::at<result_type, mpl::int_<11> >::type,
      typename mpl::at<result_type, mpl::int_<12> >::type > type;
};



template <>
struct normalise<policy<>,
          promote_float<false>,
          promote_double<false>,
          discrete_quantile<>,
          assert_undefined<>,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy>
{
   typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
};

template <>
struct normalise<policy<detail::forwarding_arg1, detail::forwarding_arg2>,
          promote_float<false>,
          promote_double<false>,
          discrete_quantile<>,
          assert_undefined<>,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy,
          default_policy>
{
   typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
};

inline policy<> make_policy()
{ return policy<>(); }

template <class A1>
inline typename normalise<policy<>, A1>::type make_policy(const A1&)
{
   typedef typename normalise<policy<>, A1>::type result_type;
   return result_type();
}

template <class A1, class A2>
inline typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&)
{
   typedef typename normalise<policy<>, A1, A2>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3>
inline typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&)
{
   typedef typename normalise<policy<>, A1, A2, A3>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4>
inline typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5>
inline typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type result_type;
   return result_type();
}

template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&)
{
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type result_type;
   return result_type();
}




template <class Real, class Policy>
struct evaluation
{
   typedef Real type;
};

template <class Policy>
struct evaluation<float, Policy>
{
   typedef typename mpl::if_<typename Policy::promote_float_type, double, float>::type type;
};

template <class Policy>
struct evaluation<double, Policy>
{
   typedef typename mpl::if_<typename Policy::promote_double_type, long double, double>::type type;
};
# 775 "/usr/include/boost-1_41/boost/math/policies/policy.hpp"
template <class Real, class Policy>
struct precision
{

   typedef typename Policy::precision_type precision_type;
   typedef typename mpl::if_c<
      ((::std::numeric_limits<Real>::is_specialized == 0) || (::std::numeric_limits<Real>::digits == 0)),

      precision_type,
      typename mpl::if_c<
         ((::std::numeric_limits<Real>::digits <= precision_type::value)
         || (Policy::precision_type::value <= 0)),

         digits2< ::std::numeric_limits<Real>::digits>,

         precision_type
      >::type
   >::type type;
# 810 "/usr/include/boost-1_41/boost/math/policies/policy.hpp"
};



namespace detail{

template <class T, class Policy>
inline int digits_imp(mpl::true_ const&)
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_820;



   typedef typename boost::math::policies::precision<T, Policy>::type p_t;
   return p_t::value;
}

template <class T, class Policy>
inline int digits_imp(mpl::false_ const&)
{
   return tools::digits<T>();
}

}

template <class T, class Policy>
inline int digits()
{
   typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
   return detail::digits_imp<T, Policy>(tag_type());
}

template <class Policy>
inline unsigned long get_max_series_iterations()
{
   typedef typename Policy::max_series_iterations_type iter_type;
   return iter_type::value;
}

template <class Policy>
inline unsigned long get_max_root_iterations()
{
   typedef typename Policy::max_root_iterations_type iter_type;
   return iter_type::value;
}

namespace detail{

template <class T, class Digits, class Small, class Default>
struct series_factor_calc
{
   static T get()
   {
      return ldexp(T(1.0), 1 - Digits::value);
   }
};

template <class T, class Digits>
struct series_factor_calc<T, Digits, mpl::true_, mpl::true_>
{
   static T get()
   {
      return boost::math::tools::epsilon<T>();
   }
};
template <class T, class Digits>
struct series_factor_calc<T, Digits, mpl::true_, mpl::false_>
{
   static T get()
   {
      static const boost::uintmax_t v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1);
      return 1 / static_cast<T>(v);
   }
};
template <class T, class Digits>
struct series_factor_calc<T, Digits, mpl::false_, mpl::true_>
{
   static T get()
   {
      return boost::math::tools::epsilon<T>();
   }
};

template <class T, class Policy>
inline T get_epsilon_imp(mpl::true_ const&)
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_898;



   typedef typename boost::math::policies::precision<T, Policy>::type p_t;
   typedef mpl::bool_<p_t::value <= std::numeric_limits<boost::uintmax_t>::digits> is_small_int;
   typedef mpl::bool_<p_t::value >= std::numeric_limits<T>::digits> is_default_value;
   return series_factor_calc<T, p_t, is_small_int, is_default_value>::get();
}

template <class T, class Policy>
inline T get_epsilon_imp(mpl::false_ const&)
{
   return tools::epsilon<T>();
}

}

template <class T, class Policy>
inline T get_epsilon()
{
   typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
   return detail::get_epsilon_imp<T, Policy>(tag_type());
}

namespace detail{

template <class A1,
          class A2,
          class A3,
          class A4,
          class A5,
          class A6,
          class A7,
          class A8,
          class A9,
          class A10,
          class A11>
char test_is_policy(const policy<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11>*);
double test_is_policy(...);

template <class P>
struct is_policy_imp
{
   static const bool value = (sizeof(::boost::math::policies::detail::test_is_policy(static_cast<P*>(0))) == 1);
};

}

template <class P>
struct is_policy : public mpl::bool_< ::boost::math::policies::detail::is_policy_imp<P>::value> {};

}}}
# 20 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 2


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 1 3
# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
#define _GLIBCXX_IOMANIP 1

       
# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3





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




  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  inline _Resetiosflags
  resetiosflags(ios_base::fmtflags __mask)
  {
    _Resetiosflags __x;
    __x._M_mask = __mask;
    return __x;
  }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
    {
      __is.setf(ios_base::fmtflags(0), __f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
    {
      __os.setf(ios_base::fmtflags(0), __f._M_mask);
      return __os;
    }


  struct _Setiosflags { ios_base::fmtflags _M_mask; };
# 92 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  inline _Setiosflags
  setiosflags(ios_base::fmtflags __mask)
  {
    _Setiosflags __x;
    __x._M_mask = __mask;
    return __x;
  }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
    {
      __is.setf(__f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
    {
      __os.setf(__f._M_mask);
      return __os;
    }


  struct _Setbase { int _M_base; };
# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  inline _Setbase
  setbase(int __base)
  {
    _Setbase __x;
    __x._M_base = __base;
    return __x;
  }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
    {
      __is.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
    {
      __os.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __os;
    }


  template<typename _CharT>
    struct _Setfill { _CharT _M_c; };
# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  template<typename _CharT>
    inline _Setfill<_CharT>
    setfill(_CharT __c)
    {
      _Setfill<_CharT> __x;
      __x._M_c = __c;
      return __x;
    }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };
# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  inline _Setprecision
  setprecision(int __n)
  {
    _Setprecision __x;
    __x._M_n = __n;
    return __x;
  }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    {
      __is.precision(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
    {
      __os.precision(__f._M_n);
      return __os;
    }


  struct _Setw { int _M_n; };
# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/iomanip" 3
  inline _Setw
  setw(int __n)
  {
    _Setw __x;
    __x._M_n = __n;
    return __x;
  }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
    {
      __is.width(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
    {
      __os.width(__f._M_n);
      return __os;
    }





  extern template ostream& operator<<(ostream&, _Setfill<char>);
  extern template ostream& operator<<(ostream&, _Setiosflags);
  extern template ostream& operator<<(ostream&, _Resetiosflags);
  extern template ostream& operator<<(ostream&, _Setbase);
  extern template ostream& operator<<(ostream&, _Setprecision);
  extern template ostream& operator<<(ostream&, _Setw);
  extern template istream& operator>>(istream&, _Setfill<char>);
  extern template istream& operator>>(istream&, _Setiosflags);
  extern template istream& operator>>(istream&, _Resetiosflags);
  extern template istream& operator>>(istream&, _Setbase);
  extern template istream& operator>>(istream&, _Setprecision);
  extern template istream& operator>>(istream&, _Setw);


  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
  extern template wostream& operator<<(wostream&, _Setiosflags);
  extern template wostream& operator<<(wostream&, _Resetiosflags);
  extern template wostream& operator<<(wostream&, _Setbase);
  extern template wostream& operator<<(wostream&, _Setprecision);
  extern template wostream& operator<<(wostream&, _Setw);
  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
  extern template wistream& operator>>(wistream&, _Setiosflags);
  extern template wistream& operator>>(wistream&, _Resetiosflags);
  extern template wistream& operator>>(wistream&, _Setbase);
  extern template wistream& operator>>(wistream&, _Setprecision);
  extern template wistream& operator>>(wistream&, _Setw);



}
# 23 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4
# 25 "/usr/include/boost-1_41/boost/math/tools/precision.hpp" 2


namespace boost{ namespace math
{
namespace tools
{
# 43 "/usr/include/boost-1_41/boost/math/tools/precision.hpp"
template <class T>
inline int digits()
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_47;



   return std::numeric_limits<T>::digits;
}

template <class T>
inline T max_value()
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_58;



   return (std::numeric_limits<T>::max)();
}


template <class T>
inline T min_value()
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_70;



   return (std::numeric_limits<T>::min)();
}

namespace detail{
# 86 "/usr/include/boost-1_41/boost/math/tools/precision.hpp"
template <class T>
inline T log_max_value(const mpl::int_<128>& )
{
   return 88.0f;
}

template <class T>
inline T log_min_value(const mpl::int_<128>& )
{
   return -87.0f;
}



template <class T>
inline T log_max_value(const mpl::int_<1024>& )
{
   return 709.0;
}

template <class T>
inline T log_min_value(const mpl::int_<1024>& )
{
   return -708.0;
}



template <class T>
inline T log_max_value(const mpl::int_<16384>& )
{
   return 11356.0L;
}

template <class T>
inline T log_min_value(const mpl::int_<16384>& )
{
   return -11355.0L;
}

template <class T>
inline T log_max_value(const mpl::int_<0>& )
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_130;



   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
   static const T val = log((std::numeric_limits<T>::max)());
   return val;
}

template <class T>
inline T log_min_value(const mpl::int_<0>& )
{

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_143;



   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
   static const T val = log((std::numeric_limits<T>::max)());
   return val;
}

template <class T>
inline T epsilon(const mpl::true_& )
{
   return std::numeric_limits<T>::epsilon();
}
# 170 "/usr/include/boost-1_41/boost/math/tools/precision.hpp"
template <class T>
inline T epsilon(const mpl::false_& )
{
   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
   static const T eps = ldexp(static_cast<T>(1), 1-policies::digits<T, policies::policy<> >());
   return eps;
}

}

template <class T>
inline T log_max_value()
{

   typedef typename mpl::if_c<
      std::numeric_limits<T>::max_exponent == 128
      || std::numeric_limits<T>::max_exponent == 1024
      || std::numeric_limits<T>::max_exponent == 16384,
      mpl::int_<std::numeric_limits<T>::max_exponent>,
      mpl::int_<0>
   >::type tag_type;
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_191;
   return detail::log_max_value<T>(tag_type());






}

template <class T>
inline T log_min_value()
{

   typedef typename mpl::if_c<
      std::numeric_limits<T>::max_exponent == 128
      || std::numeric_limits<T>::max_exponent == 1024
      || std::numeric_limits<T>::max_exponent == 16384,
      mpl::int_<std::numeric_limits<T>::max_exponent>,
      mpl::int_<0>
   >::type tag_type;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_213;
   return detail::log_min_value<T>(tag_type());






}

template <class T>
inline T epsilon()
{

   return detail::epsilon<T>(mpl::bool_< ::std::numeric_limits<T>::is_specialized>());





}

namespace detail{

template <class T>
inline T root_epsilon_imp(const mpl::int_<24>&)
{
   return static_cast<T>(0.00034526698300124390839884978618400831996329879769945L);
}

template <class T>
inline T root_epsilon_imp(const T*, const mpl::int_<53>&)
{
   return static_cast<T>(0.1490116119384765625e-7L);
}

template <class T>
inline T root_epsilon_imp(const T*, const mpl::int_<64>&)
{
   return static_cast<T>(0.32927225399135962333569506281281311031656150598474e-9L);
}

template <class T>
inline T root_epsilon_imp(const T*, const mpl::int_<113>&)
{
   return static_cast<T>(0.1387778780781445675529539585113525390625e-16L);
}

template <class T, class Tag>
inline T root_epsilon_imp(const T*, const Tag&)
{
   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
   static const T r_eps = sqrt(tools::epsilon<T>());
   return r_eps;
}

template <class T>
inline T forth_root_epsilon_imp(const T*, const mpl::int_<24>&)
{
   return static_cast<T>(0.018581361171917516667460937040007436176452688944747L);
}

template <class T>
inline T forth_root_epsilon_imp(const T*, const mpl::int_<53>&)
{
   return static_cast<T>(0.0001220703125L);
}

template <class T>
inline T forth_root_epsilon_imp(const T*, const mpl::int_<64>&)
{
   return static_cast<T>(0.18145860519450699870567321328132261891067079047605e-4L);
}

template <class T>
inline T forth_root_epsilon_imp(const T*, const mpl::int_<113>&)
{
   return static_cast<T>(0.37252902984619140625e-8L);
}

template <class T, class Tag>
inline T forth_root_epsilon_imp(const T*, const Tag&)
{
   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
   static const T r_eps = sqrt(sqrt(tools::epsilon<T>()));
   return r_eps;
}

}

template <class T>
inline T root_epsilon()
{
   typedef mpl::int_<std::numeric_limits<T>::digits> tag_type;
   return detail::root_epsilon_imp(static_cast<T const*>(0), tag_type());
}

template <class T>
inline T forth_root_epsilon()
{
   typedef mpl::int_<std::numeric_limits<T>::digits> tag_type;
   return detail::forth_root_epsilon_imp(static_cast<T const*>(0), tag_type());
}

}
}
}
# 20 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp" 2

# 1 "/usr/include/boost-1_41/boost/math/special_functions/math_fwd.hpp" 1
# 20 "/usr/include/boost-1_41/boost/math/special_functions/math_fwd.hpp"
#define BOOST_MATH_SPECIAL_MATH_FWD_HPP 






# 1 "/usr/include/boost-1_41/boost/math/tools/promotion.hpp" 1
# 19 "/usr/include/boost-1_41/boost/math/tools/promotion.hpp"
#define BOOST_MATH_PROMOTION_HPP 
# 41 "/usr/include/boost-1_41/boost/math/tools/promotion.hpp"
namespace boost
{
  namespace math
  {
    namespace tools
    {
# 67 "/usr/include/boost-1_41/boost/math/tools/promotion.hpp"
      template <class T>
      struct promote_arg
      {
        typedef typename mpl::if_<is_integral<T>, double, T>::type type;
      };


      template <> struct promote_arg<float> { typedef float type; };
      template <> struct promote_arg<double>{ typedef double type; };
      template <> struct promote_arg<long double> { typedef long double type; };
      template <> struct promote_arg<int> { typedef double type; };

      template <class T1, class T2>
      struct promote_args_2
      {

        typedef typename promote_arg<T1>::type T1P;
        typedef typename promote_arg<T2>::type T2P;

        typedef typename mpl::if_<
          typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type,
          typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type,
            long double,
            typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type,
            double,
          float
          >::type
          >::type,

          typename mpl::if_< ::boost::is_convertible<T1P, T2P>, T2P, T1P>::type>::type type;
      };


      template <> struct promote_args_2<float, float> { typedef float type; };
      template <> struct promote_args_2<double, double>{ typedef double type; };
      template <> struct promote_args_2<long double, long double> { typedef long double type; };
      template <> struct promote_args_2<int, int> { typedef double type; };
      template <> struct promote_args_2<int, float> { typedef double type; };
      template <> struct promote_args_2<float, int> { typedef double type; };
      template <> struct promote_args_2<int, double> { typedef double type; };
      template <> struct promote_args_2<double, int> { typedef double type; };
      template <> struct promote_args_2<int, long double> { typedef long double type; };
      template <> struct promote_args_2<long double, int> { typedef long double type; };
      template <> struct promote_args_2<float, double> { typedef double type; };
      template <> struct promote_args_2<double, float> { typedef double type; };
      template <> struct promote_args_2<float, long double> { typedef long double type; };
      template <> struct promote_args_2<long double, float> { typedef long double type; };
      template <> struct promote_args_2<double, long double> { typedef long double type; };
      template <> struct promote_args_2<long double, double> { typedef long double type; };

      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
      struct promote_args
      {
         typedef typename promote_args_2<
            typename remove_cv<T1>::type,
            typename promote_args_2<
               typename remove_cv<T2>::type,
               typename promote_args_2<
                  typename remove_cv<T3>::type,
                  typename promote_args_2<
                     typename remove_cv<T4>::type,
                     typename promote_args_2<
                        typename remove_cv<T5>::type, typename remove_cv<T6>::type
                     >::type
                  >::type
               >::type
            >::type
         >::type type;







      };

    }
  }
}
# 28 "/usr/include/boost-1_41/boost/math/special_functions/math_fwd.hpp" 2


# 1 "/usr/include/boost-1_41/boost/config/no_tr1/complex.hpp" 1
# 14 "/usr/include/boost-1_41/boost/config/no_tr1/complex.hpp"
#define BOOST_CONFIG_COMPLEX 


#define BOOST_TR1_NO_RECURSION 
#define BOOST_CONFIG_NO_COMPLEX_RECURSION 





#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_COMPLEX_RECURSION
# 31 "/usr/include/boost-1_41/boost/math/special_functions/math_fwd.hpp" 2

#define BOOST_NO_MACRO_EXPAND 

namespace boost
{
   namespace math
   {


   template <class RT1, class RT2>
   typename tools::promote_args<RT1, RT2>::type
         beta(RT1 a, RT2 b);

   template <class RT1, class RT2, class A>
   typename tools::promote_args<RT1, RT2, A>::type
         beta(RT1 a, RT2 b, A x);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         beta(RT1 a, RT2 b, RT3 x, const Policy& pol);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         betac(RT1 a, RT2 b, RT3 x);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         betac(RT1 a, RT2 b, RT3 x, const Policy& pol);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta(RT1 a, RT2 b, RT3 x);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac(RT1 a, RT2 b, RT3 x);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol);

   template <class T1, class T2, class T3, class T4>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ibeta_inv(T1 a, T2 b, T3 p, T4* py);

   template <class T1, class T2, class T3, class T4, class Policy>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_inv(RT1 a, RT2 b, RT3 p);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_inva(RT1 a, RT2 b, RT3 p);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_invb(RT1 a, RT2 b, RT3 p);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&);

   template <class T1, class T2, class T3, class T4>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ibetac_inv(T1 a, T2 b, T3 q, T4* py);

   template <class T1, class T2, class T3, class T4, class Policy>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_inv(RT1 a, RT2 b, RT3 q);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_inva(RT1 a, RT2 b, RT3 q);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_invb(RT1 a, RT2 b, RT3 q);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&);

   template <class RT1, class RT2, class RT3>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_derivative(RT1 a, RT2 b, RT3 x);

   template <class RT1, class RT2, class RT3, class Policy>
   typename tools::promote_args<RT1, RT2, RT3>::type
         ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol);


   template <class RT>
   typename tools::promote_args<RT>::type erf(RT z);
   template <class RT, class Policy>
   typename tools::promote_args<RT>::type erf(RT z, const Policy&);

   template <class RT>
   typename tools::promote_args<RT>::type erfc(RT z);
   template <class RT, class Policy>
   typename tools::promote_args<RT>::type erfc(RT z, const Policy&);

   template <class RT>
   typename tools::promote_args<RT>::type erf_inv(RT z);
   template <class RT, class Policy>
   typename tools::promote_args<RT>::type erf_inv(RT z, const Policy& pol);

   template <class RT>
   typename tools::promote_args<RT>::type erfc_inv(RT z);
   template <class RT, class Policy>
   typename tools::promote_args<RT>::type erfc_inv(RT z, const Policy& pol);


   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
         legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);

   template <class T>
   typename tools::promote_args<T>::type
         legendre_p(int l, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type
         legendre_p(int l, T x, const Policy& pol);

   template <class T>
   typename tools::promote_args<T>::type
         legendre_q(unsigned l, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type
         legendre_q(unsigned l, T x, const Policy& pol);

   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
         legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);

   template <class T>
   typename tools::promote_args<T>::type
         legendre_p(int l, int m, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type
         legendre_p(int l, int m, T x, const Policy& pol);

   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
         laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);

   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
      laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);

   template <class T>
   typename tools::promote_args<T>::type
      laguerre(unsigned n, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type
      laguerre(unsigned n, unsigned m, T x, const Policy& pol);

   template <class T1, class T2>
   struct laguerre_result
   {
      typedef typename mpl::if_<
         policies::is_policy<T2>,
         typename tools::promote_args<T1>::type,
         typename tools::promote_args<T2>::type
      >::type type;
   };

   template <class T1, class T2>
   typename laguerre_result<T1, T2>::type
      laguerre(unsigned n, T1 m, T2 x);

   template <class T>
   typename tools::promote_args<T>::type
      hermite(unsigned n, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type
      hermite(unsigned n, T x, const Policy& pol);

   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
      hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);

   template <class T1, class T2>
   std::complex<typename tools::promote_args<T1, T2>::type>
         spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);

   template <class T1, class T2, class Policy>
   std::complex<typename tools::promote_args<T1, T2>::type>
      spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type
         spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type
      spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type
         spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type
      spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);


   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
         ellint_rf(T1 x, T2 y, T3 z);

   template <class T1, class T2, class T3, class Policy>
   typename tools::promote_args<T1, T2, T3>::type
         ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);

   template <class T1, class T2, class T3>
   typename tools::promote_args<T1, T2, T3>::type
         ellint_rd(T1 x, T2 y, T3 z);

   template <class T1, class T2, class T3, class Policy>
   typename tools::promote_args<T1, T2, T3>::type
         ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type
         ellint_rc(T1 x, T2 y);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type
         ellint_rc(T1 x, T2 y, const Policy& pol);

   template <class T1, class T2, class T3, class T4>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ellint_rj(T1 x, T2 y, T3 z, T4 p);

   template <class T1, class T2, class T3, class T4, class Policy>
   typename tools::promote_args<T1, T2, T3, T4>::type
         ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);

   template <typename T>
   typename tools::promote_args<T>::type ellint_2(T k);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol);

   template <typename T>
   typename tools::promote_args<T>::type ellint_1(T k);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);

   namespace detail{

   template <class T, class U, class V>
   struct ellint_3_result
   {
      typedef typename mpl::if_<
         policies::is_policy<V>,
         typename tools::promote_args<T, U>::type,
         typename tools::promote_args<T, U, V>::type
      >::type type;
   };

   }


   template <class T1, class T2, class T3>
   typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);

   template <class T1, class T2, class T3, class Policy>
   typename tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v);



   template <class RT>
   struct max_factorial;
   template <class RT>
   RT factorial(unsigned int);
   template <class RT, class Policy>
   RT factorial(unsigned int, const Policy& pol);
   template <class RT>
   RT unchecked_factorial(unsigned int );
   template <class RT>
   RT double_factorial(unsigned i);
   template <class RT, class Policy>
   RT double_factorial(unsigned i, const Policy& pol);

   template <class RT>
   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n, const Policy& pol);

   template <class RT>
   typename tools::promote_args<RT>::type rising_factorial(RT x, int n);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type rising_factorial(RT x, int n, const Policy& pol);


   template <class RT>
   typename tools::promote_args<RT>::type tgamma(RT z);

   template <class RT>
   typename tools::promote_args<RT>::type tgamma1pm1(RT z);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type tgamma1pm1(RT z, const Policy& pol);

   template <class RT1, class RT2>
   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z);

   template <class RT1, class RT2, class Policy>
   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z, const Policy& pol);

   template <class RT>
   typename tools::promote_args<RT>::type lgamma(RT z, int* sign);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type lgamma(RT z, int* sign, const Policy& pol);

   template <class RT>
   typename tools::promote_args<RT>::type lgamma(RT x);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type lgamma(RT x, const Policy& pol);

   template <class RT1, class RT2>
   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z);

   template <class RT1, class RT2, class Policy>
   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z, const Policy&);

   template <class RT1, class RT2>
   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z);

   template <class RT1, class RT2, class Policy>
   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z, const Policy&);

   template <class RT1, class RT2>
   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z);

   template <class RT1, class RT2, class Policy>
   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x, const Policy&);


   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q, const Policy&);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type digamma(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type digamma(T x, const Policy&);


   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type
         hypot(T1 x, T2 y);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type
         hypot(T1 x, T2 y, const Policy&);


   template <class RT>
   typename tools::promote_args<RT>::type cbrt(RT z);

   template <class RT, class Policy>
   typename tools::promote_args<RT>::type cbrt(RT z, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type log1p(T);

   template <class T, class Policy>
   typename tools::promote_args<T>::type log1p(T, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type log1pmx(T);

   template <class T, class Policy>
   typename tools::promote_args<T>::type log1pmx(T, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type expm1(T);

   template <class T, class Policy>
   typename tools::promote_args<T>::type expm1(T, const Policy&);


   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type
         powm1(const T1 a, const T2 z);

   template <class T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type
         powm1(const T1 a, const T2 z, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type sqrt1pm1(const T& val);

   template <class T, class Policy>
   typename tools::promote_args<T>::type sqrt1pm1(const T& val, const Policy&);


   template <class T>
   typename tools::promote_args<T>::type sinc_pi(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type sinc_pi(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type sinhc_pi(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&);


   template<typename T>
   typename tools::promote_args<T>::type asinh(T x);

   template<typename T, class Policy>
   typename tools::promote_args<T>::type asinh(T x, const Policy&);

   template<typename T>
   typename tools::promote_args<T>::type acosh(T x);

   template<typename T, class Policy>
   typename tools::promote_args<T>::type acosh(T x, const Policy&);

   template<typename T>
   typename tools::promote_args<T>::type atanh(T x);

   template<typename T, class Policy>
   typename tools::promote_args<T>::type atanh(T x, const Policy&);

   namespace detail{

      typedef mpl::int_<0> bessel_no_int_tag;
      typedef mpl::int_<1> bessel_maybe_int_tag;
      typedef mpl::int_<2> bessel_int_tag;

      template <class T1, class T2, class Policy>
      struct bessel_traits
      {
         typedef typename tools::promote_args<
            T1, T2
         >::type result_type;

         typedef typename policies::precision<result_type, Policy>::type precision_type;

         typedef typename mpl::if_<
            mpl::or_<
               mpl::less_equal<precision_type, mpl::int_<0> >,
               mpl::greater<precision_type, mpl::int_<64> > >,
            bessel_no_int_tag,
            typename mpl::if_<
               is_integral<T1>,
               bessel_int_tag,
               bessel_maybe_int_tag
            >::type
         >::type optimisation_tag;
      };
   }


   template <class T1, class T2, class Policy>
   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);

   template <class T, class Policy>
   typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);

   template <class T>
   typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);

   template <class T1, class T2, class Policy>
   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);

   template <class T1, class T2, class Policy>
   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);

   template <class T1, class T2, class Policy>
   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);

   template <class T, class Policy>
   typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);

   template <class T>
   typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type sin_pi(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type sin_pi(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type cos_pi(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type cos_pi(T x);

   template <class T>
   int fpclassify (T t);

   template <class T>
   bool isfinite (T z);

   template <class T>
   bool isinf (T t);

   template <class T>
   bool isnan (T t);

   template <class T>
   bool isnormal (T t);


   namespace detail{

   template <class T, class U>
   struct expint_result
   {
      typedef typename mpl::if_<
         policies::is_policy<U>,
         typename tools::promote_args<T>::type,
         typename tools::promote_args<U>::type
      >::type type;
   };

   }

   template <class T, class Policy>
   typename tools::promote_args<T>::type expint(unsigned n, T z, const Policy&);

   template <class T, class U>
   typename detail::expint_result<T, U>::type expint(T const z, U const u);

   template <class T>
   typename tools::promote_args<T>::type expint(T z);


   template <class T, class Policy>
   typename tools::promote_args<T>::type zeta(T s, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type zeta(T s);


   template <int N, typename T, class Policy>
   typename tools::promote_args<T>::type pow(T base, const Policy& policy);

   template <int N, typename T>
   typename tools::promote_args<T>::type pow(T base);


   template <class T, class Policy>
   T nextafter(const T&, const T&, const Policy&);
   template <class T>
   T nextafter(const T&, const T&);
   template <class T, class Policy>
   T float_next(const T&, const Policy&);
   template <class T>
   T float_next(const T&);
   template <class T, class Policy>
   T float_prior(const T&, const Policy&);
   template <class T>
   T float_prior(const T&);
   template <class T, class Policy>
   T float_distance(const T&, const T&, const Policy&);
   template <class T>
   T float_distance(const T&, const T&);

    }
}


#define BOOST_MATH_DETAIL_LL_FUNC(Policy) template <class T> inline T modf(const T& v, boost::long_long_type* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); } template <class T> inline boost::long_long_type lltrunc(const T& v){ using boost::math::lltrunc; return lltrunc(v, Policy()); } template <class T> inline boost::long_long_type llround(const T& v){ using boost::math::llround; return llround(v, Policy()); }
# 719 "/usr/include/boost-1_41/boost/math/special_functions/math_fwd.hpp"
#define BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(Policy) BOOST_MATH_DETAIL_LL_FUNC(Policy) template <class RT1, class RT2> inline typename boost::math::tools::promote_args<RT1, RT2>::type beta(RT1 a, RT2 b) { return ::boost::math::beta(a, b, Policy()); } template <class RT1, class RT2, class A> inline typename boost::math::tools::promote_args<RT1, RT2, A>::type beta(RT1 a, RT2 b, A x){ return ::boost::math::beta(a, b, x, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type betac(RT1 a, RT2 b, RT3 x) { return ::boost::math::betac(a, b, x, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibeta(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta(a, b, x, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibetac(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibetac(a, b, x, Policy()); } template <class T1, class T2, class T3, class T4> inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::boost::math::ibeta_inv(a, b, p, py, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inv(a, b, p, Policy()); } template <class T1, class T2, class T3, class T4> inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::boost::math::ibetac_inv(a, b, q, py, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inva(a, b, p, Policy()); } template <class T1, class T2, class T3> inline typename boost::math::tools::promote_args<T1, T2, T3>::type ibetac_inva(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_inva(a, b, q, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_invb(a, b, p, Policy()); } template <class T1, class T2, class T3> inline typename boost::math::tools::promote_args<T1, T2, T3>::type ibetac_invb(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_invb(a, b, q, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::boost::math::ibetac_inv(a, b, q, Policy()); } template <class RT1, class RT2, class RT3> inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type erf(RT z) { return ::boost::math::erf(z, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type erfc(RT z){ return ::boost::math::erfc(z, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); } using boost::math::legendre_next; template <class T> inline typename boost::math::tools::promote_args<T>::type legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type legendre_q(unsigned l, T x){ return ::boost::math::legendre_q(l, x, Policy()); } using ::boost::math::legendre_next; template <class T> inline typename boost::math::tools::promote_args<T>::type legendre_p(int l, int m, T x){ return ::boost::math::legendre_p(l, m, x, Policy()); } using ::boost::math::laguerre_next; template <class T> inline typename boost::math::tools::promote_args<T>::type laguerre(unsigned n, T x){ return ::boost::math::laguerre(n, x, Policy()); } template <class T1, class T2> inline typename boost::math::laguerre_result<T1, T2>::type laguerre(unsigned n, T1 m, T2 x) { return ::boost::math::laguerre(n, m, x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); } using boost::math::hermite_next; template <class T1, class T2> inline std::complex<typename boost::math::tools::promote_args<T1, T2>::type> spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic(n, m, theta, phi, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::boost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); } template <class T1, class T2, class Policy> inline typename boost::math::tools::promote_args<T1, T2>::type spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol); template <class T1, class T2, class T3> inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_rf(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rf(x, y, z, Policy()); } template <class T1, class T2, class T3> inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_rd(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rd(x, y, z, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type ellint_rc(T1 x, T2 y){ return ::boost::math::ellint_rc(x, y, Policy()); } template <class T1, class T2, class T3, class T4> inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); } template <typename T> inline typename boost::math::tools::promote_args<T>::type ellint_2(T k){ return boost::math::ellint_2(k, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); } template <typename T> inline typename boost::math::tools::promote_args<T>::type ellint_1(T k){ return boost::math::ellint_1(k, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); } template <class T1, class T2, class T3> inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); } using boost::math::max_factorial; template <class RT> inline RT factorial(unsigned int i) { return boost::math::factorial<RT>(i, Policy()); } using boost::math::unchecked_factorial; template <class RT> inline RT double_factorial(unsigned i){ return boost::math::double_factorial<RT>(i, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); } using boost::math::fpclassify; template <class RT> inline typename boost::math::tools::promote_args<RT>::type tgamma(RT z){ return boost::math::tgamma(z, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); } template <class RT1, class RT2> inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type lgamma(RT x){ return boost::math::lgamma(x, Policy()); } template <class RT1, class RT2> inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); } template <class RT1, class RT2> inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); } template <class RT1, class RT2> inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type digamma(T x){ return boost::math::digamma(x, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); } template <class RT> inline typename boost::math::tools::promote_args<RT>::type cbrt(RT z){ return boost::math::cbrt(z, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type log1p(T x){ return boost::math::log1p(x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type log1pmx(T x){ return boost::math::log1pmx(x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type expm1(T x){ return boost::math::expm1(x, Policy()); } template <class T1, class T2> inline typename boost::math::tools::promote_args<T1, T2>::type powm1(const T1 a, const T2 z){ return boost::math::powm1(a, z, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); } template<typename T> inline typename boost::math::tools::promote_args<T>::type asinh(const T x){ return boost::math::asinh(x, Policy()); } template<typename T> inline typename boost::math::tools::promote_args<T>::type acosh(const T x){ return boost::math::acosh(x, Policy()); } template<typename T> inline typename boost::math::tools::promote_args<T>::type atanh(const T x){ return boost::math::atanh(x, Policy()); } template <class T1, class T2> inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x) { return boost::math::cyl_bessel_j(v, x, Policy()); } template <class T> inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x) { return boost::math::sph_bessel(v, x, Policy()); } template <class T1, class T2> inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_i(T1 v, T2 x) { return boost::math::cyl_bessel_i(v, x, Policy()); } template <class T1, class T2> inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); } template <class T1, class T2> inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); } template <class T> inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x); } template <class T> inline typename boost::math::tools::promote_args<T>::type cos_pi(T x){ return boost::math::cos_pi(x); } using boost::math::fpclassify; using boost::math::isfinite; using boost::math::isinf; using boost::math::isnan; using boost::math::isnormal; template <class T, class U> inline typename boost::math::tools::promote_args<T,U>::type expint(T const& z, U const& u) { return boost::math::expint(z, u, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type expint(T z){ return boost::math::expint(z, Policy()); } template <class T> inline typename boost::math::tools::promote_args<T>::type zeta(T s){ return boost::math::zeta(s, Policy()); } template <class T> inline T round(const T& v){ using boost::math::round; return round(v, Policy()); } template <class T> inline int iround(const T& v){ using boost::math::iround; return iround(v, Policy()); } template <class T> inline long lround(const T& v){ using boost::math::lround; return lround(v, Policy()); } template <class T> inline T trunc(const T& v){ using boost::math::trunc; return trunc(v, Policy()); } template <class T> inline int itrunc(const T& v){ using boost::math::itrunc; return itrunc(v, Policy()); } template <class T> inline long ltrunc(const T& v){ using boost::math::ltrunc; return ltrunc(v, Policy()); } template <class T> inline T modf(const T& v, T* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); } template <class T> inline T modf(const T& v, int* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); } template <class T> inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); } template <int N, class T> inline typename boost::math::tools::promote_args<T>::type pow(T v){ return boost::math::pow<N>(v, Policy()); } template <class T> T nextafter(const T& a, const T& b){ return boost::math::nextafter(a, b, Policy()); } template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); } template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); } template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }
# 22 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp" 2
# 33 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp"
namespace boost
{
    namespace math
    {
       namespace detail
       {
# 52 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp"
        template<typename T>
        inline T sinc_pi_imp(const T x)
        {





            using ::std::abs;
            using ::std::sin;
            using ::std::sqrt;



            static T const taylor_0_bound = tools::epsilon<T>();
            static T const taylor_2_bound = sqrt(taylor_0_bound);
            static T const taylor_n_bound = sqrt(taylor_2_bound);

            if (abs(x) >= taylor_n_bound)
            {
                return(sin(x)/x);
            }
            else
            {

                T result = static_cast<T>(1);

                if (abs(x) >= taylor_0_bound)
                {
                    T x2 = x*x;


                    result -= x2/static_cast<T>(6);

                    if (abs(x) >= taylor_2_bound)
                    {

                        result += (x2*x2)/static_cast<T>(120);
                    }
                }

                return(result);
            }
        }

       }

       template <class T>
       inline typename tools::promote_args<T>::type sinc_pi(T x)
       {
          typedef typename tools::promote_args<T>::type result_type;
          return detail::sinc_pi_imp(static_cast<result_type>(x));
       }

       template <class T, class Policy>
       inline typename tools::promote_args<T>::type sinc_pi(T x, const Policy&)
       {
          typedef typename tools::promote_args<T>::type result_type;
          return detail::sinc_pi_imp(static_cast<result_type>(x));
       }



        template<typename T, template<typename> class U>
        inline U<T> sinc_pi(const U<T> x)
        {

            using namespace std;
# 130 "/usr/include/boost-1_41/boost/math/special_functions/sinc.hpp"
            using ::std::numeric_limits;

            static T const taylor_0_bound = tools::epsilon<T>();
            static T const taylor_2_bound = sqrt(taylor_0_bound);
            static T const taylor_n_bound = sqrt(taylor_2_bound);

            if (abs(x) >= taylor_n_bound)
            {
                return(sin(x)/x);
            }
            else
            {




                U<T> result = U<T>(1);


                if (abs(x) >= taylor_0_bound)
                {
                    U<T> x2 = x*x;


                    result -= x2/static_cast<T>(6);

                    if (abs(x) >= taylor_2_bound)
                    {

                        result += (x2*x2)/static_cast<T>(120);
                    }
                }

                return(result);
            }
        }

        template<typename T, template<typename> class U, class Policy>
        inline U<T> sinc_pi(const U<T> x, const Policy&)
        {
           return sinc_pi(x);
        }

    }
}
# 29 "/usr/include/boost-1_41/boost/math/quaternion.hpp" 2
# 1 "/usr/include/boost-1_41/boost/math/special_functions/sinhc.hpp" 1
# 11 "/usr/include/boost-1_41/boost/math/special_functions/sinhc.hpp"
#define BOOST_SINHC_HPP 
# 31 "/usr/include/boost-1_41/boost/math/special_functions/sinhc.hpp"
namespace boost
{
    namespace math
    {
       namespace detail
       {
# 50 "/usr/include/boost-1_41/boost/math/special_functions/sinhc.hpp"
        template<typename T>
        inline T sinhc_pi_imp(const T x)
        {





            using ::std::abs;
            using ::std::sinh;
            using ::std::sqrt;


            static T const taylor_0_bound = tools::epsilon<T>();
            static T const taylor_2_bound = sqrt(taylor_0_bound);
            static T const taylor_n_bound = sqrt(taylor_2_bound);

            if (abs(x) >= taylor_n_bound)
            {
                return(sinh(x)/x);
            }
            else
            {

                T result = static_cast<T>(1);

                if (abs(x) >= taylor_0_bound)
                {
                    T x2 = x*x;


                    result += x2/static_cast<T>(6);

                    if (abs(x) >= taylor_2_bound)
                    {

                        result += (x2*x2)/static_cast<T>(120);
                    }
                }

                return(result);
            }
        }

       }

       template <class T>
       inline typename tools::promote_args<T>::type sinhc_pi(T x)
       {
          typedef typename tools::promote_args<T>::type result_type;
          return detail::sinhc_pi_imp(static_cast<result_type>(x));
       }

       template <class T, class Policy>
       inline typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&)
       {
          return boost::math::sinhc_pi(x);
       }



        template<typename T, template<typename> class U>
        inline U<T> sinhc_pi(const U<T> x)
        {

            using namespace std;
# 126 "/usr/include/boost-1_41/boost/math/special_functions/sinhc.hpp"
            using ::std::numeric_limits;

            static T const taylor_0_bound = tools::epsilon<T>();
            static T const taylor_2_bound = sqrt(taylor_0_bound);
            static T const taylor_n_bound = sqrt(taylor_2_bound);

            if (abs(x) >= taylor_n_bound)
            {
                return(sinh(x)/x);
            }
            else
            {




                U<T> result = U<T>(1);


                if (abs(x) >= taylor_0_bound)
                {
                    U<T> x2 = x*x;


                    result += x2/static_cast<T>(6);

                    if (abs(x) >= taylor_2_bound)
                    {

                        result += (x2*x2)/static_cast<T>(120);
                    }
                }

                return(result);
            }
        }

    }
}
# 30 "/usr/include/boost-1_41/boost/math/quaternion.hpp" 2


namespace boost
{
    namespace math
    {
# 54 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_ACCESSOR_GENERATOR(type) type real() const { return(a); } quaternion<type> unreal() const { return(quaternion<type>(static_cast<type>(0),b,c,d)); } type R_component_1() const { return(a); } type R_component_2() const { return(b); } type R_component_3() const { return(c); } type R_component_4() const { return(d); } ::std::complex<type> C_component_1() const { return(::std::complex<type>(a,b)); } ::std::complex<type> C_component_2() const { return(::std::complex<type>(c,d)); }
# 96 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(type) template<typename X> quaternion<type> & operator = (quaternion<X> const & a_affecter) { a = static_cast<type>(a_affecter.R_component_1()); b = static_cast<type>(a_affecter.R_component_2()); c = static_cast<type>(a_affecter.R_component_3()); d = static_cast<type>(a_affecter.R_component_4()); return(*this); } quaternion<type> & operator = (quaternion<type> const & a_affecter) { a = a_affecter.a; b = a_affecter.b; c = a_affecter.c; d = a_affecter.d; return(*this); } quaternion<type> & operator = (type const & a_affecter) { a = a_affecter; b = c = d = static_cast<type>(0); return(*this); } quaternion<type> & operator = (::std::complex<type> const & a_affecter) { a = a_affecter.real(); b = a_affecter.imag(); c = d = static_cast<type>(0); return(*this); }
# 138 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_DATA_GENERATOR(type) type a; type b; type c; type d;






        template<typename T>
        class quaternion
        {
        public:

            typedef T value_type;





            explicit quaternion( T const & requested_a = T(),
                                            T const & requested_b = T(),
                                            T const & requested_c = T(),
                                            T const & requested_d = T())
            : a(requested_a),
                b(requested_b),
                c(requested_c),
                d(requested_d)
            {

            }




            explicit quaternion( ::std::complex<T> const & z0,
                                            ::std::complex<T> const & z1 = ::std::complex<T>())
            : a(z0.real()),
                b(z0.imag()),
                c(z1.real()),
                d(z1.imag())
            {

            }
# 188 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
            template<typename X>
            explicit quaternion(quaternion<X> const & a_recopier)
            : a(static_cast<T>(a_recopier.R_component_1())),
                b(static_cast<T>(a_recopier.R_component_2())),
                c(static_cast<T>(a_recopier.R_component_3())),
                d(static_cast<T>(a_recopier.R_component_4()))
            {

            }
# 212 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
            T real() const { return(a); } quaternion<T> unreal() const { return(quaternion<T>(static_cast<T>(0),b,c,d)); } T R_component_1() const { return(a); } T R_component_2() const { return(b); } T R_component_3() const { return(c); } T R_component_4() const { return(d); } ::std::complex<T> C_component_1() const { return(::std::complex<T>(a,b)); } ::std::complex<T> C_component_2() const { return(::std::complex<T>(c,d)); }



            template<typename X> quaternion<T> & operator = (quaternion<X> const & a_affecter) { a = static_cast<T>(a_affecter.R_component_1()); b = static_cast<T>(a_affecter.R_component_2()); c = static_cast<T>(a_affecter.R_component_3()); d = static_cast<T>(a_affecter.R_component_4()); return(*this); } quaternion<T> & operator = (quaternion<T> const & a_affecter) { a = a_affecter.a; b = a_affecter.b; c = a_affecter.c; d = a_affecter.d; return(*this); } quaternion<T> & operator = (T const & a_affecter) { a = a_affecter; b = c = d = static_cast<T>(0); return(*this); } quaternion<T> & operator = (::std::complex<T> const & a_affecter) { a = a_affecter.real(); b = a_affecter.imag(); c = d = static_cast<T>(0); return(*this); }







            quaternion<T> & operator += (T const & rhs)
            {
                T at = a + rhs;

                a = at;

                return(*this);
            }


            quaternion<T> & operator += (::std::complex<T> const & rhs)
            {
                T at = a + rhs.real();
                T bt = b + rhs.imag();

                a = at;
                b = bt;

                return(*this);
            }


            template<typename X>
            quaternion<T> & operator += (quaternion<X> const & rhs)
            {
                T at = a + static_cast<T>(rhs.R_component_1());
                T bt = b + static_cast<T>(rhs.R_component_2());
                T ct = c + static_cast<T>(rhs.R_component_3());
                T dt = d + static_cast<T>(rhs.R_component_4());

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }



            quaternion<T> & operator -= (T const & rhs)
            {
                T at = a - rhs;

                a = at;

                return(*this);
            }


            quaternion<T> & operator -= (::std::complex<T> const & rhs)
            {
                T at = a - rhs.real();
                T bt = b - rhs.imag();

                a = at;
                b = bt;

                return(*this);
            }


            template<typename X>
            quaternion<T> & operator -= (quaternion<X> const & rhs)
            {
                T at = a - static_cast<T>(rhs.R_component_1());
                T bt = b - static_cast<T>(rhs.R_component_2());
                T ct = c - static_cast<T>(rhs.R_component_3());
                T dt = d - static_cast<T>(rhs.R_component_4());

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


            quaternion<T> & operator *= (T const & rhs)
            {
                T at = a * rhs;
                T bt = b * rhs;
                T ct = c * rhs;
                T dt = d * rhs;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


            quaternion<T> & operator *= (::std::complex<T> const & rhs)
            {
                T ar = rhs.real();
                T br = rhs.imag();

                T at = +a*ar-b*br;
                T bt = +a*br+b*ar;
                T ct = +c*ar+d*br;
                T dt = -c*br+d*ar;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


            template<typename X>
            quaternion<T> & operator *= (quaternion<X> const & rhs)
            {
                T ar = static_cast<T>(rhs.R_component_1());
                T br = static_cast<T>(rhs.R_component_2());
                T cr = static_cast<T>(rhs.R_component_3());
                T dr = static_cast<T>(rhs.R_component_4());

                T at = +a*ar-b*br-c*cr-d*dr;
                T bt = +a*br+b*ar+c*dr-d*cr;
                T ct = +a*cr-b*dr+c*ar+d*br;
                T dt = +a*dr+b*cr-c*br+d*ar;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }



            quaternion<T> & operator /= (T const & rhs)
            {
                T at = a / rhs;
                T bt = b / rhs;
                T ct = c / rhs;
                T dt = d / rhs;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


            quaternion<T> & operator /= (::std::complex<T> const & rhs)
            {
                T ar = rhs.real();
                T br = rhs.imag();

                T denominator = ar*ar+br*br;

                T at = (+a*ar+b*br)/denominator;
                T bt = (-a*br+b*ar)/denominator;
                T ct = (+c*ar-d*br)/denominator;
                T dt = (+c*br+d*ar)/denominator;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


            template<typename X>
            quaternion<T> & operator /= (quaternion<X> const & rhs)
            {
                T ar = static_cast<T>(rhs.R_component_1());
                T br = static_cast<T>(rhs.R_component_2());
                T cr = static_cast<T>(rhs.R_component_3());
                T dr = static_cast<T>(rhs.R_component_4());

                T denominator = ar*ar+br*br+cr*cr+dr*dr;

                T at = (+a*ar+b*br+c*cr+d*dr)/denominator;
                T bt = (-a*br+b*ar-c*dr+d*cr)/denominator;
                T ct = (-a*cr+b*dr+c*ar-d*br)/denominator;
                T dt = (-a*dr-b*cr+c*br+d*ar)/denominator;

                a = at;
                b = bt;
                c = ct;
                d = dt;

                return(*this);
            }


        protected:

            T a; T b; T c; T d;


        private:

        };




        template<> class quaternion<float>;
        template<> class quaternion<double>;
        template<> class quaternion<long double>;




        namespace detail
        {

            template< typename T,
                        typename U
                    >
            quaternion<T> quaternion_type_converter(quaternion<U> const & rhs);
        }





#define BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(type) explicit quaternion( type const & requested_a = static_cast<type>(0), type const & requested_b = static_cast<type>(0), type const & requested_c = static_cast<type>(0), type const & requested_d = static_cast<type>(0)) : a(requested_a), b(requested_b), c(requested_c), d(requested_d) { } explicit quaternion( ::std::complex<type> const & z0, ::std::complex<type> const & z1 = ::std::complex<type>()) : a(z0.real()), b(z0.imag()), c(z1.real()), d(z1.imag()) { }
# 476 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) quaternion<type> & operator += (type const & rhs) { a += rhs; return(*this); }







#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) quaternion<type> & operator += (::std::complex<type> const & rhs) { a += rhs.real(); b += rhs.imag(); return(*this); }
# 493 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type) template<typename X> quaternion<type> & operator += (quaternion<X> const & rhs) { a += static_cast<type>(rhs.R_component_1()); b += static_cast<type>(rhs.R_component_2()); c += static_cast<type>(rhs.R_component_3()); d += static_cast<type>(rhs.R_component_4()); return(*this); }
# 505 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) quaternion<type> & operator -= (type const & rhs) { a -= rhs; return(*this); }







#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) quaternion<type> & operator -= (::std::complex<type> const & rhs) { a -= rhs.real(); b -= rhs.imag(); return(*this); }
# 522 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type) template<typename X> quaternion<type> & operator -= (quaternion<X> const & rhs) { a -= static_cast<type>(rhs.R_component_1()); b -= static_cast<type>(rhs.R_component_2()); c -= static_cast<type>(rhs.R_component_3()); d -= static_cast<type>(rhs.R_component_4()); return(*this); }
# 534 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) quaternion<type> & operator *= (type const & rhs) { a *= rhs; b *= rhs; c *= rhs; d *= rhs; return(*this); }
# 545 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) quaternion<type> & operator *= (::std::complex<type> const & rhs) { type ar = rhs.real(); type br = rhs.imag(); type at = +a*ar-b*br; type bt = +a*br+b*ar; type ct = +c*ar+d*br; type dt = -c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); }
# 564 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type) template<typename X> quaternion<type> & operator *= (quaternion<X> const & rhs) { type ar = static_cast<type>(rhs.R_component_1()); type br = static_cast<type>(rhs.R_component_2()); type cr = static_cast<type>(rhs.R_component_3()); type dr = static_cast<type>(rhs.R_component_4()); type at = +a*ar-b*br-c*cr-d*dr; type bt = +a*br+b*ar+c*dr-d*cr; type ct = +a*cr-b*dr+c*ar+d*br; type dt = +a*dr+b*cr-c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); }
# 593 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) quaternion<type> & operator /= (type const & rhs) { a /= rhs; b /= rhs; c /= rhs; d /= rhs; return(*this); }
# 672 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) quaternion<type> & operator /= (::std::complex<type> const & rhs) { using ::std::valarray; valarray<type> tr(2); tr[0] = rhs.real(); tr[1] = rhs.imag(); type mixam = static_cast<type>(1)/(abs(tr).max)(); tr *= mixam; valarray<type> tt(4); tt[0] = +a*tr[0]+b*tr[1]; tt[1] = -a*tr[1]+b*tr[0]; tt[2] = +c*tr[0]-d*tr[1]; tt[3] = +c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); }
# 780 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) template<typename X> quaternion<type> & operator /= (quaternion<X> const & rhs) { using ::std::valarray; valarray<type> tr(4); tr[0] = static_cast<type>(rhs.R_component_1()); tr[1] = static_cast<type>(rhs.R_component_2()); tr[2] = static_cast<type>(rhs.R_component_3()); tr[3] = static_cast<type>(rhs.R_component_4()); type mixam = static_cast<type>(1)/(abs(tr).max)(); tr *= mixam; valarray<type> tt(4); tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); }
# 817 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type)




#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type)




#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type)




#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type) BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type)




#define BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(type) BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type)






        template<>
        class quaternion<float>
        {
        public:

            typedef float value_type;

            explicit quaternion( float const & requested_a = static_cast<float>(0), float const & requested_b = static_cast<float>(0), float const & requested_c = static_cast<float>(0), float const & requested_d = static_cast<float>(0)) : a(requested_a), b(requested_b), c(requested_c), d(requested_d) { } explicit quaternion( ::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>()) : a(z0.real()), b(z0.imag()), c(z1.real()), d(z1.imag()) { }






            explicit quaternion(quaternion<double> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<float, double>(a_recopier);
            }

            explicit quaternion(quaternion<long double> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<float, long double>(a_recopier);
            }
# 880 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
            float real() const { return(a); } quaternion<float> unreal() const { return(quaternion<float>(static_cast<float>(0),b,c,d)); } float R_component_1() const { return(a); } float R_component_2() const { return(b); } float R_component_3() const { return(c); } float R_component_4() const { return(d); } ::std::complex<float> C_component_1() const { return(::std::complex<float>(a,b)); } ::std::complex<float> C_component_2() const { return(::std::complex<float>(c,d)); }



            template<typename X> quaternion<float> & operator = (quaternion<X> const & a_affecter) { a = static_cast<float>(a_affecter.R_component_1()); b = static_cast<float>(a_affecter.R_component_2()); c = static_cast<float>(a_affecter.R_component_3()); d = static_cast<float>(a_affecter.R_component_4()); return(*this); } quaternion<float> & operator = (quaternion<float> const & a_affecter) { a = a_affecter.a; b = a_affecter.b; c = a_affecter.c; d = a_affecter.d; return(*this); } quaternion<float> & operator = (float const & a_affecter) { a = a_affecter; b = c = d = static_cast<float>(0); return(*this); } quaternion<float> & operator = (::std::complex<float> const & a_affecter) { a = a_affecter.real(); b = a_affecter.imag(); c = d = static_cast<float>(0); return(*this); }







            quaternion<float> & operator += (float const & rhs) { a += rhs; return(*this); } quaternion<float> & operator += (::std::complex<float> const & rhs) { a += rhs.real(); b += rhs.imag(); return(*this); } template<typename X> quaternion<float> & operator += (quaternion<X> const & rhs) { a += static_cast<float>(rhs.R_component_1()); b += static_cast<float>(rhs.R_component_2()); c += static_cast<float>(rhs.R_component_3()); d += static_cast<float>(rhs.R_component_4()); return(*this); } quaternion<float> & operator -= (float const & rhs) { a -= rhs; return(*this); } quaternion<float> & operator -= (::std::complex<float> const & rhs) { a -= rhs.real(); b -= rhs.imag(); return(*this); } template<typename X> quaternion<float> & operator -= (quaternion<X> const & rhs) { a -= static_cast<float>(rhs.R_component_1()); b -= static_cast<float>(rhs.R_component_2()); c -= static_cast<float>(rhs.R_component_3()); d -= static_cast<float>(rhs.R_component_4()); return(*this); } quaternion<float> & operator *= (float const & rhs) { a *= rhs; b *= rhs; c *= rhs; d *= rhs; return(*this); } quaternion<float> & operator *= (::std::complex<float> const & rhs) { float ar = rhs.real(); float br = rhs.imag(); float at = +a*ar-b*br; float bt = +a*br+b*ar; float ct = +c*ar+d*br; float dt = -c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } template<typename X> quaternion<float> & operator *= (quaternion<X> const & rhs) { float ar = static_cast<float>(rhs.R_component_1()); float br = static_cast<float>(rhs.R_component_2()); float cr = static_cast<float>(rhs.R_component_3()); float dr = static_cast<float>(rhs.R_component_4()); float at = +a*ar-b*br-c*cr-d*dr; float bt = +a*br+b*ar+c*dr-d*cr; float ct = +a*cr-b*dr+c*ar+d*br; float dt = +a*dr+b*cr-c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } quaternion<float> & operator /= (float const & rhs) { a /= rhs; b /= rhs; c /= rhs; d /= rhs; return(*this); } quaternion<float> & operator /= (::std::complex<float> const & rhs) { using ::std::valarray; valarray<float> tr(2); tr[0] = rhs.real(); tr[1] = rhs.imag(); float mixam = static_cast<float>(1)/(abs(tr).max)(); tr *= mixam; valarray<float> tt(4); tt[0] = +a*tr[0]+b*tr[1]; tt[1] = -a*tr[1]+b*tr[0]; tt[2] = +c*tr[0]-d*tr[1]; tt[3] = +c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); } template<typename X> quaternion<float> & operator /= (quaternion<X> const & rhs) { using ::std::valarray; valarray<float> tr(4); tr[0] = static_cast<float>(rhs.R_component_1()); tr[1] = static_cast<float>(rhs.R_component_2()); tr[2] = static_cast<float>(rhs.R_component_3()); tr[3] = static_cast<float>(rhs.R_component_4()); float mixam = static_cast<float>(1)/(abs(tr).max)(); tr *= mixam; valarray<float> tt(4); tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); }


        protected:

            float a; float b; float c; float d;


        private:

        };


        template<>
        class quaternion<double>
        {
        public:

            typedef double value_type;

            explicit quaternion( double const & requested_a = static_cast<double>(0), double const & requested_b = static_cast<double>(0), double const & requested_c = static_cast<double>(0), double const & requested_d = static_cast<double>(0)) : a(requested_a), b(requested_b), c(requested_c), d(requested_d) { } explicit quaternion( ::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>()) : a(z0.real()), b(z0.imag()), c(z1.real()), d(z1.imag()) { }






            explicit quaternion(quaternion<float> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<double, float>(a_recopier);
            }



            explicit quaternion(quaternion<long double> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<double, long double>(a_recopier);
            }
# 943 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
            double real() const { return(a); } quaternion<double> unreal() const { return(quaternion<double>(static_cast<double>(0),b,c,d)); } double R_component_1() const { return(a); } double R_component_2() const { return(b); } double R_component_3() const { return(c); } double R_component_4() const { return(d); } ::std::complex<double> C_component_1() const { return(::std::complex<double>(a,b)); } ::std::complex<double> C_component_2() const { return(::std::complex<double>(c,d)); }



            template<typename X> quaternion<double> & operator = (quaternion<X> const & a_affecter) { a = static_cast<double>(a_affecter.R_component_1()); b = static_cast<double>(a_affecter.R_component_2()); c = static_cast<double>(a_affecter.R_component_3()); d = static_cast<double>(a_affecter.R_component_4()); return(*this); } quaternion<double> & operator = (quaternion<double> const & a_affecter) { a = a_affecter.a; b = a_affecter.b; c = a_affecter.c; d = a_affecter.d; return(*this); } quaternion<double> & operator = (double const & a_affecter) { a = a_affecter; b = c = d = static_cast<double>(0); return(*this); } quaternion<double> & operator = (::std::complex<double> const & a_affecter) { a = a_affecter.real(); b = a_affecter.imag(); c = d = static_cast<double>(0); return(*this); }







            quaternion<double> & operator += (double const & rhs) { a += rhs; return(*this); } quaternion<double> & operator += (::std::complex<double> const & rhs) { a += rhs.real(); b += rhs.imag(); return(*this); } template<typename X> quaternion<double> & operator += (quaternion<X> const & rhs) { a += static_cast<double>(rhs.R_component_1()); b += static_cast<double>(rhs.R_component_2()); c += static_cast<double>(rhs.R_component_3()); d += static_cast<double>(rhs.R_component_4()); return(*this); } quaternion<double> & operator -= (double const & rhs) { a -= rhs; return(*this); } quaternion<double> & operator -= (::std::complex<double> const & rhs) { a -= rhs.real(); b -= rhs.imag(); return(*this); } template<typename X> quaternion<double> & operator -= (quaternion<X> const & rhs) { a -= static_cast<double>(rhs.R_component_1()); b -= static_cast<double>(rhs.R_component_2()); c -= static_cast<double>(rhs.R_component_3()); d -= static_cast<double>(rhs.R_component_4()); return(*this); } quaternion<double> & operator *= (double const & rhs) { a *= rhs; b *= rhs; c *= rhs; d *= rhs; return(*this); } quaternion<double> & operator *= (::std::complex<double> const & rhs) { double ar = rhs.real(); double br = rhs.imag(); double at = +a*ar-b*br; double bt = +a*br+b*ar; double ct = +c*ar+d*br; double dt = -c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } template<typename X> quaternion<double> & operator *= (quaternion<X> const & rhs) { double ar = static_cast<double>(rhs.R_component_1()); double br = static_cast<double>(rhs.R_component_2()); double cr = static_cast<double>(rhs.R_component_3()); double dr = static_cast<double>(rhs.R_component_4()); double at = +a*ar-b*br-c*cr-d*dr; double bt = +a*br+b*ar+c*dr-d*cr; double ct = +a*cr-b*dr+c*ar+d*br; double dt = +a*dr+b*cr-c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } quaternion<double> & operator /= (double const & rhs) { a /= rhs; b /= rhs; c /= rhs; d /= rhs; return(*this); } quaternion<double> & operator /= (::std::complex<double> const & rhs) { using ::std::valarray; valarray<double> tr(2); tr[0] = rhs.real(); tr[1] = rhs.imag(); double mixam = static_cast<double>(1)/(abs(tr).max)(); tr *= mixam; valarray<double> tt(4); tt[0] = +a*tr[0]+b*tr[1]; tt[1] = -a*tr[1]+b*tr[0]; tt[2] = +c*tr[0]-d*tr[1]; tt[3] = +c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); } template<typename X> quaternion<double> & operator /= (quaternion<X> const & rhs) { using ::std::valarray; valarray<double> tr(4); tr[0] = static_cast<double>(rhs.R_component_1()); tr[1] = static_cast<double>(rhs.R_component_2()); tr[2] = static_cast<double>(rhs.R_component_3()); tr[3] = static_cast<double>(rhs.R_component_4()); double mixam = static_cast<double>(1)/(abs(tr).max)(); tr *= mixam; valarray<double> tt(4); tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); }


        protected:

            double a; double b; double c; double d;


        private:

        };


        template<>
        class quaternion<long double>
        {
        public:

            typedef long double value_type;

            explicit quaternion( long double const & requested_a = static_cast<long double>(0), long double const & requested_b = static_cast<long double>(0), long double const & requested_c = static_cast<long double>(0), long double const & requested_d = static_cast<long double>(0)) : a(requested_a), b(requested_b), c(requested_c), d(requested_d) { } explicit quaternion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>()) : a(z0.real()), b(z0.imag()), c(z1.real()), d(z1.imag()) { }






            explicit quaternion(quaternion<float> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<long double, float>(a_recopier);
            }

            explicit quaternion(quaternion<double> const & a_recopier)
            {
                *this = detail::quaternion_type_converter<long double, double>(a_recopier);
            }
# 1004 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
            long double real() const { return(a); } quaternion<long double> unreal() const { return(quaternion<long double>(static_cast<long double>(0),b,c,d)); } long double R_component_1() const { return(a); } long double R_component_2() const { return(b); } long double R_component_3() const { return(c); } long double R_component_4() const { return(d); } ::std::complex<long double> C_component_1() const { return(::std::complex<long double>(a,b)); } ::std::complex<long double> C_component_2() const { return(::std::complex<long double>(c,d)); }



            template<typename X> quaternion<long double> & operator = (quaternion<X> const & a_affecter) { a = static_cast<long double>(a_affecter.R_component_1()); b = static_cast<long double>(a_affecter.R_component_2()); c = static_cast<long double>(a_affecter.R_component_3()); d = static_cast<long double>(a_affecter.R_component_4()); return(*this); } quaternion<long double> & operator = (quaternion<long double> const & a_affecter) { a = a_affecter.a; b = a_affecter.b; c = a_affecter.c; d = a_affecter.d; return(*this); } quaternion<long double> & operator = (long double const & a_affecter) { a = a_affecter; b = c = d = static_cast<long double>(0); return(*this); } quaternion<long double> & operator = (::std::complex<long double> const & a_affecter) { a = a_affecter.real(); b = a_affecter.imag(); c = d = static_cast<long double>(0); return(*this); }







            quaternion<long double> & operator += (long double const & rhs) { a += rhs; return(*this); } quaternion<long double> & operator += (::std::complex<long double> const & rhs) { a += rhs.real(); b += rhs.imag(); return(*this); } template<typename X> quaternion<long double> & operator += (quaternion<X> const & rhs) { a += static_cast<long double>(rhs.R_component_1()); b += static_cast<long double>(rhs.R_component_2()); c += static_cast<long double>(rhs.R_component_3()); d += static_cast<long double>(rhs.R_component_4()); return(*this); } quaternion<long double> & operator -= (long double const & rhs) { a -= rhs; return(*this); } quaternion<long double> & operator -= (::std::complex<long double> const & rhs) { a -= rhs.real(); b -= rhs.imag(); return(*this); } template<typename X> quaternion<long double> & operator -= (quaternion<X> const & rhs) { a -= static_cast<long double>(rhs.R_component_1()); b -= static_cast<long double>(rhs.R_component_2()); c -= static_cast<long double>(rhs.R_component_3()); d -= static_cast<long double>(rhs.R_component_4()); return(*this); } quaternion<long double> & operator *= (long double const & rhs) { a *= rhs; b *= rhs; c *= rhs; d *= rhs; return(*this); } quaternion<long double> & operator *= (::std::complex<long double> const & rhs) { long double ar = rhs.real(); long double br = rhs.imag(); long double at = +a*ar-b*br; long double bt = +a*br+b*ar; long double ct = +c*ar+d*br; long double dt = -c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } template<typename X> quaternion<long double> & operator *= (quaternion<X> const & rhs) { long double ar = static_cast<long double>(rhs.R_component_1()); long double br = static_cast<long double>(rhs.R_component_2()); long double cr = static_cast<long double>(rhs.R_component_3()); long double dr = static_cast<long double>(rhs.R_component_4()); long double at = +a*ar-b*br-c*cr-d*dr; long double bt = +a*br+b*ar+c*dr-d*cr; long double ct = +a*cr-b*dr+c*ar+d*br; long double dt = +a*dr+b*cr-c*br+d*ar; a = at; b = bt; c = ct; d = dt; return(*this); } quaternion<long double> & operator /= (long double const & rhs) { a /= rhs; b /= rhs; c /= rhs; d /= rhs; return(*this); } quaternion<long double> & operator /= (::std::complex<long double> const & rhs) { using ::std::valarray; valarray<long double> tr(2); tr[0] = rhs.real(); tr[1] = rhs.imag(); long double mixam = static_cast<long double>(1)/(abs(tr).max)(); tr *= mixam; valarray<long double> tt(4); tt[0] = +a*tr[0]+b*tr[1]; tt[1] = -a*tr[1]+b*tr[0]; tt[2] = +c*tr[0]-d*tr[1]; tt[3] = +c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); } template<typename X> quaternion<long double> & operator /= (quaternion<X> const & rhs) { using ::std::valarray; valarray<long double> tr(4); tr[0] = static_cast<long double>(rhs.R_component_1()); tr[1] = static_cast<long double>(rhs.R_component_2()); tr[2] = static_cast<long double>(rhs.R_component_3()); tr[3] = static_cast<long double>(rhs.R_component_4()); long double mixam = static_cast<long double>(1)/(abs(tr).max)(); tr *= mixam; valarray<long double> tt(4); tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; tr *= tr; tt *= (mixam/tr.sum()); a = tt[0]; b = tt[1]; c = tt[2]; d = tt[3]; return(*this); }


        protected:

            long double a; long double b; long double c; long double d;


        private:

        };


#undef BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR
#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR
#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR
#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR
#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR
#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1
#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2
#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3
#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1
#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2
#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3
#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1
#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2
#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3
#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1
#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2
#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3

#undef BOOST_QUATERNION_CONSTRUCTOR_GENERATOR


#undef BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR

#undef BOOST_QUATERNION_MEMBER_DATA_GENERATOR

#undef BOOST_QUATERNION_ACCESSOR_GENERATOR




#define BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) { quaternion<T> res(lhs); res op ##= rhs; return(res); }






#define BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) template<typename T> inline quaternion<T> operator op (T const & lhs, quaternion<T> const & rhs) BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)




#define BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) template<typename T> inline quaternion<T> operator op (quaternion<T> const & lhs, T const & rhs) BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)




#define BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) template<typename T> inline quaternion<T> operator op (::std::complex<T> const & lhs, quaternion<T> const & rhs) BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)




#define BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) template<typename T> inline quaternion<T> operator op (quaternion<T> const & lhs, ::std::complex<T> const & rhs) BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)




#define BOOST_QUATERNION_OPERATOR_GENERATOR_3(op) template<typename T> inline quaternion<T> operator op (quaternion<T> const & lhs, quaternion<T> const & rhs) BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)




#define BOOST_QUATERNION_OPERATOR_GENERATOR(op) BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) BOOST_QUATERNION_OPERATOR_GENERATOR_3(op)







        template<typename T> inline quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res += rhs; return(res); } template<typename T> inline quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs) { quaternion<T> res(lhs); res += rhs; return(res); } template<typename T> inline quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res += rhs; return(res); } template<typename T> inline quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs) { quaternion<T> res(lhs); res += rhs; return(res); } template<typename T> inline quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res += rhs; return(res); }
        template<typename T> inline quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res -= rhs; return(res); } template<typename T> inline quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs) { quaternion<T> res(lhs); res -= rhs; return(res); } template<typename T> inline quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res -= rhs; return(res); } template<typename T> inline quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs) { quaternion<T> res(lhs); res -= rhs; return(res); } template<typename T> inline quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res -= rhs; return(res); }
        template<typename T> inline quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res *= rhs; return(res); } template<typename T> inline quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs) { quaternion<T> res(lhs); res *= rhs; return(res); } template<typename T> inline quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res *= rhs; return(res); } template<typename T> inline quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs) { quaternion<T> res(lhs); res *= rhs; return(res); } template<typename T> inline quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res *= rhs; return(res); }
        template<typename T> inline quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res /= rhs; return(res); } template<typename T> inline quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs) { quaternion<T> res(lhs); res /= rhs; return(res); } template<typename T> inline quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res /= rhs; return(res); } template<typename T> inline quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs) { quaternion<T> res(lhs); res /= rhs; return(res); } template<typename T> inline quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs) { quaternion<T> res(lhs); res /= rhs; return(res); }


#undef BOOST_QUATERNION_OPERATOR_GENERATOR

#undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_L
#undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_R
#undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_L
#undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_R
#undef BOOST_QUATERNION_OPERATOR_GENERATOR_3

#undef BOOST_QUATERNION_OPERATOR_GENERATOR_BODY


        template<typename T>
        inline quaternion<T> operator + (quaternion<T> const & q)
        {
            return(q);
        }


        template<typename T>
        inline quaternion<T> operator - (quaternion<T> const & q)
        {
            return(quaternion<T>(-q.R_component_1(),-q.R_component_2(),-q.R_component_3(),-q.R_component_4()));
        }


        template<typename T>
        inline bool operator == (T const & lhs, quaternion<T> const & rhs)
        {
            return (
                        (rhs.R_component_1() == lhs)&&
                        (rhs.R_component_2() == static_cast<T>(0))&&
                        (rhs.R_component_3() == static_cast<T>(0))&&
                        (rhs.R_component_4() == static_cast<T>(0))
                    );
        }


        template<typename T>
        inline bool operator == (quaternion<T> const & lhs, T const & rhs)
        {
            return (
                        (lhs.R_component_1() == rhs)&&
                        (lhs.R_component_2() == static_cast<T>(0))&&
                        (lhs.R_component_3() == static_cast<T>(0))&&
                        (lhs.R_component_4() == static_cast<T>(0))
                    );
        }


        template<typename T>
        inline bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs)
        {
            return (
                        (rhs.R_component_1() == lhs.real())&&
                        (rhs.R_component_2() == lhs.imag())&&
                        (rhs.R_component_3() == static_cast<T>(0))&&
                        (rhs.R_component_4() == static_cast<T>(0))
                    );
        }


        template<typename T>
        inline bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs)
        {
            return (
                        (lhs.R_component_1() == rhs.real())&&
                        (lhs.R_component_2() == rhs.imag())&&
                        (lhs.R_component_3() == static_cast<T>(0))&&
                        (lhs.R_component_4() == static_cast<T>(0))
                    );
        }


        template<typename T>
        inline bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs)
        {
            return (
                        (rhs.R_component_1() == lhs.R_component_1())&&
                        (rhs.R_component_2() == lhs.R_component_2())&&
                        (rhs.R_component_3() == lhs.R_component_3())&&
                        (rhs.R_component_4() == lhs.R_component_4())
                    );
        }


#define BOOST_QUATERNION_NOT_EQUAL_GENERATOR { return(!(lhs == rhs)); }




        template<typename T>
        inline bool operator != (T const & lhs, quaternion<T> const & rhs)
        { return(!(lhs == rhs)); }

        template<typename T>
        inline bool operator != (quaternion<T> const & lhs, T const & rhs)
        { return(!(lhs == rhs)); }

        template<typename T>
        inline bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs)
        { return(!(lhs == rhs)); }

        template<typename T>
        inline bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs)
        { return(!(lhs == rhs)); }

        template<typename T>
        inline bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs)
        { return(!(lhs == rhs)); }

#undef BOOST_QUATERNION_NOT_EQUAL_GENERATOR
# 1227 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
        template<typename T, typename charT, class traits>
        ::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is,
                                                                quaternion<T> & q)

        {






            const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc());


            T a = T();
            T b = T();
            T c = T();
            T d = T();

            ::std::complex<T> u = ::std::complex<T>();
            ::std::complex<T> v = ::std::complex<T>();

            charT ch = charT();
            char cc;

            is >> ch;

            if (!is.good()) goto finish;




            cc = ct.narrow(ch, char());


            if (cc == '(')
            {
                is >> ch;

                if (!is.good()) goto finish;




                cc = ct.narrow(ch, char());


                if (cc == '(')
                {
                    is.putback(ch);

                    is >> u;
                    a = u.real();
                    b = u.imag();

                    if (!is.good()) goto finish;

                    is >> ch;

                    if (!is.good()) goto finish;




                    cc = ct.narrow(ch, char());


                    if (cc == ')')
                    {
                        q = quaternion<T>(a,b);
                    }
                    else if (cc == ',')
                    {
                        is >> v;
                        c = v.real();
                        d = v.imag();

                        if (!is.good()) goto finish;

                        is >> ch;

                        if (!is.good()) goto finish;




                        cc = ct.narrow(ch, char());


                        if (cc == ')')
                        {
                            q = quaternion<T>(a,b,c,d);
                        }
                        else
                        {



                            is.setstate(::std::ios_base::failbit);

                        }
                    }
                    else
                    {



                        is.setstate(::std::ios_base::failbit);

                    }
                }
                else
                {
                    is.putback(ch);

                    is >> a;

                    if (!is.good()) goto finish;

                    is >> ch;

                    if (!is.good()) goto finish;




                    cc = ct.narrow(ch, char());


                    if (cc == ')')
                    {
                        q = quaternion<T>(a);
                    }
                    else if (cc == ',')
                    {
                        is >> ch;

                        if (!is.good()) goto finish;




                        cc = ct.narrow(ch, char());


                        if (cc == '(')
                        {
                            is.putback(ch);

                            is >> v;

                            c = v.real();
                            d = v.imag();

                            if (!is.good()) goto finish;

                            is >> ch;

                            if (!is.good()) goto finish;




                            cc = ct.narrow(ch, char());


                            if (cc == ')')
                            {
                                q = quaternion<T>(a,b,c,d);
                            }
                            else
                            {



                                is.setstate(::std::ios_base::failbit);

                            }
                        }
                        else
                        {
                            is.putback(ch);

                            is >> b;

                            if (!is.good()) goto finish;

                            is >> ch;

                            if (!is.good()) goto finish;




                            cc = ct.narrow(ch, char());


                            if (cc == ')')
                            {
                                q = quaternion<T>(a,b);
                            }
                            else if (cc == ',')
                            {
                                is >> c;

                                if (!is.good()) goto finish;

                                is >> ch;

                                if (!is.good()) goto finish;




                                cc = ct.narrow(ch, char());


                                if (cc == ')')
                                {
                                    q = quaternion<T>(a,b,c);
                                }
                                else if (cc == ',')
                                {
                                    is >> d;

                                    if (!is.good()) goto finish;

                                    is >> ch;

                                    if (!is.good()) goto finish;




                                    cc = ct.narrow(ch, char());


                                    if (cc == ')')
                                    {
                                        q = quaternion<T>(a,b,c,d);
                                    }
                                    else
                                    {



                                        is.setstate(::std::ios_base::failbit);

                                    }
                                }
                                else
                                {



                                    is.setstate(::std::ios_base::failbit);

                                }
                            }
                            else
                            {



                                is.setstate(::std::ios_base::failbit);

                            }
                        }
                    }
                    else
                    {



                        is.setstate(::std::ios_base::failbit);

                    }
                }
            }
            else
            {
                is.putback(ch);

                is >> a;

                if (!is.good()) goto finish;

                q = quaternion<T>(a);
            }

            finish:
            return(is);
        }







        template<typename T, typename charT, class traits>
        ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os,
                                                                quaternion<T> const & q)

        {



            ::std::basic_ostringstream<charT,traits> s;


            s.flags(os.flags());


            s.imbue(os.getloc());

            s.precision(os.precision());

            s << '(' << q.R_component_1() << ','
                        << q.R_component_2() << ','
                        << q.R_component_3() << ','
                        << q.R_component_4() << ')';

            return os << s.str();
        }




        template<typename T>
        inline T real(quaternion<T> const & q)
        {
            return(q.real());
        }


        template<typename T>
        inline quaternion<T> unreal(quaternion<T> const & q)
        {
            return(q.unreal());
        }


#define BOOST_QUATERNION_VALARRAY_LOADER using ::std::valarray; valarray<T> temp(4); temp[0] = q.R_component_1(); temp[1] = q.R_component_2(); temp[2] = q.R_component_3(); temp[3] = q.R_component_4();
# 1581 "/usr/include/boost-1_41/boost/math/quaternion.hpp"
        template<typename T>
        inline T sup(quaternion<T> const & q)
        {




            using ::std::valarray; valarray<T> temp(4); temp[0] = q.R_component_1(); temp[1] = q.R_component_2(); temp[2] = q.R_component_3(); temp[3] = q.R_component_4();




            return((abs(temp).max)());

        }


        template<typename T>
        inline T l1(quaternion<T> const & q)
        {




            using ::std::valarray; valarray<T> temp(4); temp[0] = q.R_component_1(); temp[1] = q.R_component_2(); temp[2] = q.R_component_3(); temp[3] = q.R_component_4();




            return(abs(temp).sum());

        }


        template<typename T>
        inline T abs(quaternion<T> const & q)
        {




            using ::std::sqrt;

            using ::std::valarray; valarray<T> temp(4); temp[0] = q.R_component_1(); temp[1] = q.R_component_2(); temp[2] = q.R_component_3(); temp[3] = q.R_component_4();




            T maxim = (abs(temp).max)();


            if (maxim == static_cast<T>(0))
            {
                return(maxim);
            }
            else
            {
                T mixam = static_cast<T>(1)/maxim;

                temp *= mixam;

                temp *= temp;

                return(maxim*sqrt(temp.sum()));
            }


        }


#undef BOOST_QUATERNION_VALARRAY_LOADER




        template<typename T>
        inline T norm(quaternion<T>const & q)
        {
            return(real(q*conj(q)));
        }


        template<typename T>
        inline quaternion<T> conj(quaternion<T> const & q)
        {
            return(quaternion<T>( +q.R_component_1(),
                                    -q.R_component_2(),
                                    -q.R_component_3(),
                                    -q.R_component_4()));
        }


        template<typename T>
        inline quaternion<T> spherical( T const & rho,
                                                            T const & theta,
                                                            T const & phi1,
                                                            T const & phi2)
        {
            using ::std::cos;
            using ::std::sin;






            T courrant = static_cast<T>(1);

            T d = sin(phi2);

            courrant *= cos(phi2);

            T c = sin(phi1)*courrant;

            courrant *= cos(phi1);

            T b = sin(theta)*courrant;
            T a = cos(theta)*courrant;

            return(rho*quaternion<T>(a,b,c,d));
        }


        template<typename T>
        inline quaternion<T> semipolar( T const & rho,
                                                            T const & alpha,
                                                            T const & theta1,
                                                            T const & theta2)
        {
            using ::std::cos;
            using ::std::sin;

            T a = cos(alpha)*cos(theta1);
            T b = cos(alpha)*sin(theta1);
            T c = sin(alpha)*cos(theta2);
            T d = sin(alpha)*sin(theta2);

            return(rho*quaternion<T>(a,b,c,d));
        }


        template<typename T>
        inline quaternion<T> multipolar( T const & rho1,
                                                            T const & theta1,
                                                            T const & rho2,
                                                            T const & theta2)
        {
            using ::std::cos;
            using ::std::sin;

            T a = rho1*cos(theta1);
            T b = rho1*sin(theta1);
            T c = rho2*cos(theta2);
            T d = rho2*sin(theta2);

            return(quaternion<T>(a,b,c,d));
        }


        template<typename T>
        inline quaternion<T> cylindrospherical( T const & t,
                                                                    T const & radius,
                                                                    T const & longitude,
                                                                    T const & latitude)
        {
            using ::std::cos;
            using ::std::sin;



            T b = radius*cos(longitude)*cos(latitude);
            T c = radius*sin(longitude)*cos(latitude);
            T d = radius*sin(latitude);

            return(quaternion<T>(t,b,c,d));
        }


        template<typename T>
        inline quaternion<T> cylindrical(T const & r,
                                                            T const & angle,
                                                            T const & h1,
                                                            T const & h2)
        {
            using ::std::cos;
            using ::std::sin;

            T a = r*cos(angle);
            T b = r*sin(angle);

            return(quaternion<T>(a,b,h1,h2));
        }






        template<typename T>
        inline quaternion<T> exp(quaternion<T> const & q)
        {
            using ::std::exp;
            using ::std::cos;

            using ::boost::math::sinc_pi;

            T u = exp(real(q));

            T z = abs(unreal(q));

            T w = sinc_pi(z);

            return(u*quaternion<T>(cos(z),
                w*q.R_component_2(), w*q.R_component_3(),
                w*q.R_component_4()));
        }


        template<typename T>
        inline quaternion<T> cos(quaternion<T> const & q)
        {
            using ::std::sin;
            using ::std::cos;
            using ::std::cosh;

            using ::boost::math::sinhc_pi;

            T z = abs(unreal(q));

            T w = -sin(q.real())*sinhc_pi(z);

            return(quaternion<T>(cos(q.real())*cosh(z),
                w*q.R_component_2(), w*q.R_component_3(),
                w*q.R_component_4()));
        }


        template<typename T>
        inline quaternion<T> sin(quaternion<T> const & q)
        {
            using ::std::sin;
            using ::std::cos;
            using ::std::cosh;

            using ::boost::math::sinhc_pi;

            T z = abs(unreal(q));

            T w = +cos(q.real())*sinhc_pi(z);

            return(quaternion<T>(sin(q.real())*cosh(z),
                w*q.R_component_2(), w*q.R_component_3(),
                w*q.R_component_4()));
        }


        template<typename T>
        inline quaternion<T> tan(quaternion<T> const & q)
        {
            return(sin(q)/cos(q));
        }


        template<typename T>
        inline quaternion<T> cosh(quaternion<T> const & q)
        {
            return((exp(+q)+exp(-q))/static_cast<T>(2));
        }


        template<typename T>
        inline quaternion<T> sinh(quaternion<T> const & q)
        {
            return((exp(+q)-exp(-q))/static_cast<T>(2));
        }


        template<typename T>
        inline quaternion<T> tanh(quaternion<T> const & q)
        {
            return(sinh(q)/cosh(q));
        }


        template<typename T>
        quaternion<T> pow(quaternion<T> const & q,
                                                    int n)
        {
            if (n > 1)
            {
                int m = n>>1;

                quaternion<T> result = pow(q, m);

                result *= result;

                if (n != (m<<1))
                {
                    result *= q;
                }

                return(result);
            }
            else if (n == 1)
            {
                return(q);
            }
            else if (n == 0)
            {
                return(quaternion<T>(1));
            }
            else
            {
                return(pow(quaternion<T>(1)/q,-n));
            }
        }




        namespace detail
        {

            template< typename T,
                        typename U
                    >
            quaternion<T> quaternion_type_converter(quaternion<U> const & rhs)
            {
                return(quaternion<T>( static_cast<T>(rhs.R_component_1()),
                                        static_cast<T>(rhs.R_component_2()),
                                        static_cast<T>(rhs.R_component_3()),
                                        static_cast<T>(rhs.R_component_4())));
            }
        }
    }
}
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp" 2

namespace rw { namespace math {
# 47 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
    template<class T = double>
    class Quaternion :
        public boost::math::quaternion<T>,
        public Rotation3DVector<T>
    {
    private:
        typedef boost::math::quaternion<T> Base_quaternion;

    public:
        Quaternion() : Base_quaternion(0, 0, 0, 1) {}
# 65 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
        Quaternion(T qx, T qy, T qz, T qw) : Base_quaternion(qx, qy, qz, qw) {}





        Quaternion(const Quaternion<T>& quat) : Base_quaternion(quat) {}







        Quaternion(const Rotation3D<T>& rot) : Base_quaternion()
        {
            setRotation(rot);
        }





        Quaternion(const Base_quaternion& r) : Base_quaternion(r) {}





        void operator=(const Base_quaternion& r)
        {
            Base_quaternion::operator=(r);
        }





        T getQx() const { return Base_quaternion::R_component_1(); }





        T getQy() const { return Base_quaternion::R_component_2(); }





        T getQz() const { return Base_quaternion::R_component_3(); }





        T getQw() const { return Base_quaternion::R_component_4(); }






        T getLength() const
        {
            return static_cast<T>(sqrt(getLengthSquared()));
        }






        T getLengthSquared() const
        {
            return static_cast<T>(
                this->a * this->a +
                this->b * this->b +
                this->c * this->c +
                this->d * this->d);
        }





        void normalize()
        {
            const T mag = getLengthSquared();

            if (fabs(mag - 1.0) > 1e-5) {
                const T n = sqrt(mag);
                this->a /= n;
                this->b /= n;
                this->c /= n;
                this->d /= n;
            }
        };
# 180 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
        const Rotation3D<T> toRotation3D() const
        {
            T qx = this->a;
            T qy = this->b;
            T qz = this->c;
            T qw = this->d;

            return
                Rotation3D<T>(
                    1-2*qy*qy-2*qz*qz, 2*(qx*qy-qz*qw) , 2*(qx*qz+qy*qw),
                    2*(qx*qy+qz*qw) , 1-2*qx*qx-2*qz*qz , 2*(qy*qz-qx*qw),
                    2*(qx*qz-qy*qw) , 2*(qy*qz+qx*qw) , 1-2*qx*qx-2*qy*qy);
        }






        const T& operator()(size_t i) const
        {
            switch(i){
            case 0: return this->a;
            case 1: return this->b;
            case 2: return this->c;
            case 3: return this->d;
            default:
                ((0) ? static_cast<void> (0) : __assert_fail ("0", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp", 207, __PRETTY_FUNCTION__));
                return this->a;
            }
        }






        T& operator()(size_t i)
        {
            switch(i){
            case 0: return this->a;
            case 1: return this->b;
            case 2: return this->c;
            case 3: return this->d;
            default:
                ((0) ? static_cast<void> (0) : __assert_fail ("0", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp", 225, __PRETTY_FUNCTION__));
                return this->a;
            }
        }
# 238 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
        const Quaternion<T> slerp(const Quaternion<T>& v, const T t) const
        {
            const T qax = this->a;
            const T qay = this->b;
            const T qaz = this->c;
            const T qaw = this->d;
            const T qbx = v(0);
            const T qby = v(1);
            const T qbz = v(2);
            const T qbw = v(3);


            const T cosHalfTheta = qaw * qbw + qax * qbx + qay * qby + qaz * qbz;


            if (fabs(cosHalfTheta) >= 1.0) {
                return Quaternion<T>(qax, qay, qaz, qaw);

            }


            const T halfTheta = acos(cosHalfTheta);
            const T sinHalfTheta = (T)sqrt(1.0 - cosHalfTheta * cosHalfTheta);



            if (fabs(sinHalfTheta) < static_cast<T>(0.001)){
                const T t05 = static_cast<T>(0.5);
                T qmw = (qaw * t05 + qbw * t05);
                T qmx = (qax * t05 + qbx * t05);
                T qmy = (qay * t05 + qby * t05);
                T qmz = (qaz * t05 + qbz * t05);
                return Quaternion<T>(qmx,qmy,qmz,qmw);
            }

            const T ratioA = sin((1 - t) * halfTheta) / sinHalfTheta;
            const T ratioB = sin(t * halfTheta) / sinHalfTheta;


            const T qmw = (qaw * ratioA + qbw * ratioB);
            const T qmx = (qax * ratioA + qbx * ratioB);
            const T qmy = (qay * ratioA + qby * ratioB);
            const T qmz = (qaz * ratioA + qbz * ratioB);
            return Quaternion<T>(qmx,qmy,qmz,qmw);
        }




        friend const Quaternion<T> operator*(const Quaternion<T>& v, T s)
        {
            Quaternion<T> q(v);
            q *= s;
            return q;
        }




        friend const Quaternion<T> operator*(T s, const Quaternion<T>& v)
        {
            Quaternion<T> q(v);
            q *= s;
            return q;
        }
# 325 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
        template <class R>
        void setRotation(const Rotation3D<R>& rot)
        {
            const T tr = static_cast<T>(rot(0, 0) + rot(1, 1) + rot(2, 2) + 1);

            if (tr > 1e-5) {
                const T s = static_cast<T>(0.5) / static_cast<T>(sqrt(tr));
                this->d = static_cast<T>(0.25) / s;
                this->a = static_cast<T>(rot(2, 1) - rot(1, 2)) * s;
                this->b = static_cast<T>(rot(0, 2) - rot(2, 0)) * s;
                this->c = static_cast<T>(rot(1, 0) - rot(0, 1)) * s;
            } else {
                if (rot(0, 0) > rot(1, 1) && rot(0, 0) > rot(2, 2)) {
                    const T sa = static_cast<T>(sqrt(rot(0, 0) - rot(1, 1) - rot(2, 2) + 1.0));
                    this->a = static_cast<T>(0.5) * sa;


                    const T s = static_cast<T>(0.25) / this->a;
                    this->b = static_cast<T>(rot(0, 1) + rot(1, 0)) * s;
                    this->c = static_cast<T>(rot(0, 2) + rot(2, 0)) * s;
                    this->d = static_cast<T>(rot(1, 2) - rot(2, 1)) * s;
                } else if (rot(1, 1) > rot(2, 2)) {
                    const T sb = static_cast<T>(sqrt(rot(1, 1) - rot(2, 2) - rot(0, 0) + 1));
                    this->b = static_cast<T>(0.5) * sb;

                    const T s = static_cast<T>(0.25) / this->b;
                    this->a = static_cast<T>(rot(0, 1) + rot(1, 0)) * s;
                    this->c = static_cast<T>(rot(1, 2) + rot(2, 1)) * s;
                    this->d = static_cast<T>(rot(0, 2) - rot(2, 0)) * s;
                } else {
                    const T sc = static_cast<T>(sqrt(rot(2, 2) - rot(0, 0) - rot(1, 1) + 1));
                    this->c = static_cast<T>(0.5) * sc;

                    const T s = static_cast<T>(0.25) / this->c;
                    this->a = static_cast<T>(rot(0, 2) + rot(2, 0)) * s;
                    this->b = static_cast<T>(rot(1, 2) + rot(2, 1)) * s;
                    this->d = static_cast<T>(rot(0, 1) - rot(1, 0)) * s;
                }
            }
        }
# 373 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Quaternion.hpp"
        template<class Q>
        friend const Quaternion<Q> cast(const Quaternion<T>& quaternion)
        {
            return Quaternion<Q>(
                static_cast<Q>(quaternion(0)),
                static_cast<Q>(quaternion(1)),
                static_cast<Q>(quaternion(2)),
                static_cast<Q>(quaternion(3)));
        }
    };






    template <class T>
    std::ostream& operator<<(std::ostream& out, const Quaternion<T>& v)
    {
        return out
            << "Quaternion {"
            << v(0)
            << ", "
            << v(1)
            << ", "
            << v(2)
            << ", "
            << v(3)
            << "}";
    }


}}
# 36 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
#define RW_MATH_ROTATION2D_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Vector2D.hpp" 1
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp" 2





namespace rw { namespace math {

    template<class T> class Rotation2DVector;
# 58 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
    template<class T = double>
    class Rotation2D
    {
    public:

        typedef boost::numeric::ublas::bounded_matrix<T, 2, 2> Base;




        Rotation2D() : _matrix(2, 2)
        {}
# 89 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        Rotation2D(T r11, T r12, T r21, T r22)
            : _matrix(2, 2)
        {
            m()(0, 0) = r11;
            m()(0, 1) = r12;
            m()(1, 0) = r21;
            m()(1, 1) = r22;
        }
# 111 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        Rotation2D(const Vector2D<T>& i, const Vector2D<T>& j)
            : _matrix(2, 2)
        {
            m()(0, 0) = i[0];
            m()(0, 1) = j[0];
            m()(1, 0) = i[1];
            m()(1, 1) = j[1];
        }
# 132 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        Rotation2D(const T theta)
            : _matrix(2, 2)
        {
            m()(0, 0) = cos(theta);
            m()(0, 1) = -sin(theta);
            m()(1, 0) = sin(theta);
            m()(1, 1) = cos(theta);
        }
# 148 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        Rotation2D(const Vector2D<T>& i)
            : _matrix(2, 2)
        {
            m()(0, 0) = i[0]; m()(0, 1) = -i[1];
            m()(1, 0) = i[1]; m()(1, 1) = i[0];
        }
# 169 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        static const Rotation2D& identity()
        {
            static Rotation2D id(
                boost::numeric::ublas::identity_matrix<T>(2));
            return id;
        }
# 183 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        T& operator()(size_t row, size_t column)
        {
            return m()(row, column);
        }







        const T& operator()(size_t row, size_t column) const
        {
            return m()(row, column);
        }







        const Base& m() const
        {
            return _matrix;
        }







        Base& m()
        {
            return _matrix;
        }
# 231 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        friend const Rotation2D operator*(const Rotation2D& aRb, const Rotation2D& bRc)
        {
            return Rotation2D(prod(aRb.m(), bRc.m()));
        }
# 244 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        friend const Vector2D<T> operator*(const Rotation2D& aRb, const Vector2D<T>& bVc)
        {
            return Vector2D<T>(prod(aRb.m(), bVc.m()));
        }







        friend std::ostream& operator<<(std::ostream &os, const Rotation2D& r)
        {
            return os
                << "Rotation2D {"
                << r(0, 0) << ", " << r(0, 1) << ", "
                << r(1, 0) << ", " << r(1, 1)
                << "}";
        }






        template<class Q>
        friend const Rotation2D<Q> cast(const Rotation2D<T>& rot)
        {
            Rotation2D<Q> res(Rotation2D<Q>::identity());
            for (size_t i = 0; i < 2; i++)
                for (size_t j = 0; j < 2; j++)
                    res(i, j) = static_cast<Q>(rot(i, j));
            return res;
        }
# 287 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
        template <class R>
        explicit Rotation2D(
            const boost::numeric::ublas::matrix_expression<R>& r) : _matrix(r)
        {}

    private:
        Base _matrix;
    };
# 310 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Rotation2D.hpp"
    template <class T>
    const Rotation2D<T> inverse(const Rotation2D<T>& aRb)
    {
        return Rotation2D<T>(trans(aRb.m()));
    }


}}
# 37 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
#define RW_MATH_VELOCITYSCREW6D_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Transform3D.hpp" 1
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/EAA.hpp" 1
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp" 2


namespace rw { namespace math {
# 60 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
    template<class T = double>
    class VelocityScrew6D
    {
        typedef boost::numeric::ublas::bounded_vector<T, 6> Base;
        Base _screw;

    public:
# 77 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        VelocityScrew6D(T vx, T vy, T vz, T wx, T wy, T wz);




        VelocityScrew6D() : _screw(boost::numeric::ublas::zero_vector<T>(6))
        {}







        explicit VelocityScrew6D(const Transform3D<T>& transform);







        VelocityScrew6D(const Vector3D<T>& linear, const EAA<T>& angular);






        const Vector3D<T> linear() const {
            return Vector3D<T>(m()(0), m()(1), m()(2));
        }







        const EAA<T> angular() const {
            return EAA<T>(m()(3), m()(4), m()(5));
        }
# 127 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        T& operator()(std::size_t index) {
            ((index < 6) ? static_cast<void> (0) : __assert_fail ("index < 6", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp", 128, __PRETTY_FUNCTION__));
            return m()(index);
        }
# 139 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        const T& operator()(std::size_t index) const {
            ((index < 6) ? static_cast<void> (0) : __assert_fail ("index < 6", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp", 140, __PRETTY_FUNCTION__));
            return m()(index);
        }
# 152 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        VelocityScrew6D<T>& operator+=(const VelocityScrew6D<T>& screw) {
            m() += screw.m();
            return *this;
        }
# 166 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        VelocityScrew6D<T>& operator-=(const VelocityScrew6D<T>& screw) {
            m() -= screw.m();
            return *this;
        }
# 179 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        VelocityScrew6D<T>& operator *= (T s) {
            m() *= s;
            return *this;
        }
# 191 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator*(T s, const VelocityScrew6D& screw) {
            VelocityScrew6D result = screw;
            result *= s;
            return result;
        }
# 204 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator*(const VelocityScrew6D& screw, T s) {
            VelocityScrew6D result = screw;
            result *= s;
            return result;
        }
# 257 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator*(const Transform3D<T>& aTb,
                                                  const VelocityScrew6D<T>& bV)
        {
            const Vector3D<T>& bv = bV.linear();
            const EAA<T>& bw = bV.angular();
            const EAA<T>& aw = aTb.R() * bw;
            const Vector3D<T>& av = aTb.R() * bv + cross(aTb.P(), aw);
            return VelocityScrew6D<T>(av, aw);
        }
# 314 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator*(const Vector3D<T>& aPb,
                                                  const VelocityScrew6D<T>& bV)
        {
            const Vector3D<T>& bv = bV.linear();
            const EAA<T>& bw = bV.angular();
            const Vector3D<T>& av = bv + cross(aPb, bw);
            return VelocityScrew6D<T>(av, bw);
        }
# 364 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator*(const Rotation3D<T>& aRb, const VelocityScrew6D<T>& bV)
        {
            Vector3D<T> bv = bV.linear();
            EAA<T> bw = bV.angular();

            return VelocityScrew6D<T>(aRb*bv, aRb*bw);
        }
# 382 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator+(const VelocityScrew6D<T>& screw1,
                                                  const VelocityScrew6D<T>& screw2)
        {
            return VelocityScrew6D<T>(screw1.m()+screw2.m());
        }
# 396 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend const VelocityScrew6D<T> operator-(const VelocityScrew6D<T>& screw1,
                                                  const VelocityScrew6D<T>& screw2)
        {
            return VelocityScrew6D<T>(screw1.m()-screw2.m());
        }
# 409 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend std::ostream& operator<<(std::ostream& os, const VelocityScrew6D<T>& screw)
        {
            return os << screw.m();
        }
# 421 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend T norm_1(const VelocityScrew6D& screw)
        {
            return norm_1(screw.m());
        }
# 433 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        T norm1(const VelocityScrew6D& screw){
            return norm_1(m());
        }
# 445 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend T norm_2(const VelocityScrew6D& screw)
        {
            return norm_2(screw.m());
        }
# 457 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        T norm2(const VelocityScrew6D& screw)
        {
            return norm_2(m());
        }
# 470 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        friend T norm_inf(const VelocityScrew6D& screw)
        {
            return norm_inf(screw.m());
        }







        T normInf()
        {
            return norm_inf(m());
        }
# 493 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/VelocityScrew6D.hpp"
        template<class Q>
        friend const VelocityScrew6D<Q> cast(const VelocityScrew6D<T>& vs)
        {
            return VelocityScrew6D<Q>(
                static_cast<Q>(vs(0)),
                static_cast<Q>(vs(1)),
                static_cast<Q>(vs(2)),
                static_cast<Q>(vs(3)),
                static_cast<Q>(vs(4)),
                static_cast<Q>(vs(5)));
        }




        template <class R>
        explicit VelocityScrew6D(const boost::numeric::ublas::vector_expression<R>& r)
            : _screw(r)
        {}




        const Base& m() const { return _screw; }




        Base& m() { return _screw; }
    };


}}
# 38 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Path.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Path.hpp"
#define RW_TRAJECTORY_PATH_HPP 
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Path.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
#define RW_KINEMATICS_STATE_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
#define RW_KINEMATICS_QSTATE_HPP 
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
namespace rw { namespace kinematics {
    class StateSetup;
    class StateData;
# 53 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
    class QState
    {
    public:



        QState();
# 70 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
        explicit QState(boost::shared_ptr<StateSetup> setup);


        virtual ~QState() {

        }
# 86 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
        const double* getQ(const StateData& data) const;
# 106 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
        void setQ(const StateData& data, const double* vals);
# 117 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp"
        friend std::ostream& operator<<(std::ostream& os, const QState& state)
        {
            os << state._contents;
            return os;
        }




        friend QState operator*(const QState& q, double scale)
        {
            return QState(scale * q._contents, q._setup);
        }




        friend QState operator/(const QState& q, double scale)
        {
            return QState(q._contents/scale, q._setup);
        }




        friend QState operator*(double scale, const QState& q)
        {
            return QState(scale * q._contents, q._setup);
        }




        friend QState operator+(const QState& a, const QState& b)
        {


            return QState(a._contents + b._contents, a._setup);
        }




        friend QState operator-(const QState& a, const QState& b)
        {
            return QState(a._contents - b._contents, a._setup);
        }




        QState operator-() const
        {
            return QState(-_contents, _setup);
        }




        boost::shared_ptr<StateSetup> getStateSetup() const{
            return _setup;
        }



        QState& operator=(const QState &rhs);





        size_t size() const { return _contents.size(); }

        double& operator()(size_t index) {
            ((index<size()) ? (void)0 : rw::common::IOUtil::rwAssert("index<size()", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp", 191));
            return _contents(index);
        }

        const double& operator()(size_t index) const {
            ((index<size()) ? (void)0 : rw::common::IOUtil::rwAssert("index<size()", "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/QState.hpp", 196));
            return _contents(index);
        }

    private:
        QState(
            const math::Q& contents,
            boost::shared_ptr<StateSetup> setup)
            :
            _contents(contents),
            _setup(setup)
        {}

    private:
        math::Q _contents;
        boost::shared_ptr<StateSetup> _setup;
    };


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
#define RW_KINEMATICS_TREESTATE_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
namespace rw { namespace kinematics {

    class Frame;
    class StateSetup;
# 49 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
    class TreeState
    {
    public:
        typedef std::vector<Frame*> FrameList;



        TreeState();




        explicit TreeState(boost::shared_ptr<StateSetup> setup);




        virtual ~TreeState();
# 80 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
        const Frame* getParent(const Frame* frame) const;




        Frame* getParent(Frame* frame) const;
# 101 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
        const FrameList& getChildren(const Frame* frame) const;
# 117 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/TreeState.hpp"
        void attachFrame(Frame* frame, Frame* parent);





        boost::shared_ptr<StateSetup> getStateSetup() const;

    private:
        boost::shared_ptr<StateSetup> _setup;



        std::vector< int > _parentIdxToChildList;



        std::vector< FrameList > _childLists;



        std::vector<int> _dafIdxToParentIdx;

    };


}}
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp" 2





namespace rw { namespace kinematics {

    class Frame;
    class StateSetup;
    class StateStructure;
    typedef rw::common::Ptr<StateStructure> StateStructurePtr;
# 68 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
    class State
    {
    public:





        State();
# 88 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        void setQStateInState(State& to) const
        { to.getQState() = getQState(); }
# 105 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        void setTreeStateInState(State& to) const
        { to.getTreeState() = getTreeState(); }






        friend State operator*(const State& state, double scale)
        {
            return State(state._q_state * scale, state._tree_state);
        }






        friend State operator/(const State& state, double scale)
        {
            return State(state._q_state / scale, state._tree_state);
        }






        friend State operator*(double scale, const State& state)
        {
            return State(scale * state._q_state, state._tree_state);
        }
# 146 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        friend State operator+(const State& a, const State& b)
        {
            return State(a._q_state + b._q_state, a._tree_state);
        }
# 159 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        friend State operator-(const State& a, const State& b)
        {
            return State(a._q_state - b._q_state, a._tree_state);
        }






        State operator-() const
        {
            return State(-_q_state, _tree_state);
        }






        void copy(const State &state);






        void upgradeTo(const State &state)
        {
            State newState = state;
            newState.copy(*this);
            *this = newState;
        }
# 200 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        size_t size() const { return getQState().size(); }
# 209 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp"
        double& operator()(size_t index) { return getQState()(index); }






        const double& operator()(size_t index) const { return getQState()(index); }




        double& operator[](size_t index) { return operator()(index); }




        const double& operator[](size_t index) const { return operator()(index); }





        Frame* getFrame(int id);


        typedef double value_type;






        StateStructurePtr getStateStructure() const;
    private:
        friend class StateData;
        friend class Frame;
        friend class StateStructure;



        const QState& getQState() const { return _q_state; }




        QState& getQState() { return _q_state; }




        const TreeState& getTreeState() const { return _tree_state; }




        TreeState& getTreeState() { return _tree_state; }




        State(const QState& q_state,
              const TreeState& tree_state) :
            _tree_state(tree_state),
            _q_state(q_state)
        {}

    private:
        TreeState _tree_state;
        QState _q_state;
    };


}}
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Path.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Timed.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Timed.hpp"
#define RW_TRAJECTORY_TIMED_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Timed.hpp"
namespace rw { namespace trajectory {







    template <class T>
    class Timed
    {
    public:



        Timed(double time, const T& value) :
            _time(time),
            _value(value)
        {}




        Timed() : _time(), _value() {}




        double getTime() const { return _time; }




        const T& getValue() const { return _value; }

    private:
        double _time;
        T _value;
    };




    template <class T>
    Timed<T> makeTimed(double time, const T& value) { return Timed<T>(time, value); }


    typedef Timed<rw::math::Q> TimedQ;


    typedef Timed<rw::kinematics::State> TimedState;


}}
# 34 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/trajectory/Path.hpp" 2

namespace rw { namespace trajectory {



    typedef std::vector<rw::math::Q> QPath;




    typedef rw::common::Ptr<QPath> QPathPtr;





    typedef std::vector<rw::math::Vector3D<> > Vector3DPath;




    typedef rw::common::Ptr<Vector3DPath> Vector3DPathPtr;





    typedef std::vector<rw::math::Rotation3D<> > Rotation3DPath;




    typedef rw::common::Ptr<Rotation3DPath> Rotation3DPathPtr;





    typedef std::vector<rw::math::Transform3D<> > Transform3DPath;




    typedef rw::common::Ptr<Transform3DPath> Transform3DPathPtr;





    typedef std::vector<rw::kinematics::State> StatePath;




    typedef rw::common::Ptr<StatePath> StatePathPtr;






    typedef std::vector<TimedQ> TimedQPath;




    typedef rw::common::Ptr<TimedQPath> TimedQPathPtr;





    typedef std::vector<TimedState> TimedStatePath;




    typedef rw::common::Ptr<TimedStatePath> TimedStatePathPtr;


}}
# 40 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp" 2

namespace rw { namespace common {


    class PropertyMap;
# 55 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyType.hpp"
    class PropertyType
    {
    public:



        typedef enum {
          Unknown = -1,
                PropertyMap = 0,
                String,
                Float,
                Double,
                Int,
                Bool,
                Vector3D,
                Vector2D,
                Q,
                Transform3D,
                Rotation3D,
                RPY,
                EAA,
                Quaternion,
                Rotation2D,
                VelocityScrew6D,
                QPath,
                Transform3DPath,
                User
                } Types;




        PropertyType() : _id(Unknown) {}







        PropertyType(int id) : _id(id) {}





        static int getNewID();





        int getId() const { return _id; }




        static PropertyType getType(const rw::common::PropertyMap&) { return PropertyType(PropertyMap); }
        static PropertyType getType(const std::string&) { return PropertyType(String); }
        static PropertyType getType(float) { return PropertyType(Float); }
        static PropertyType getType(double) { return PropertyType(Double); }
        static PropertyType getType(int) { return PropertyType(Int); }
        static PropertyType getType(bool) { return PropertyType(Bool); }
        static PropertyType getType(const rw::math::Vector3D<>&) { return PropertyType(Vector3D); }
        static PropertyType getType(const rw::math::Vector2D<>&) { return PropertyType(Vector2D); }
        static PropertyType getType(const rw::math::Q&) { return PropertyType(Q); }
        static PropertyType getType(const rw::math::Transform3D<>&) { return PropertyType(Transform3D); }
        static PropertyType getType(const rw::math::Rotation3D<>&) { return PropertyType(Rotation3D); }
        static PropertyType getType(const rw::math::RPY<>&) { return PropertyType(RPY); }
        static PropertyType getType(const rw::math::EAA<>&) { return PropertyType(EAA); }
        static PropertyType getType(const rw::math::Quaternion<>&) { return PropertyType(Quaternion); }
        static PropertyType getType(const rw::math::Rotation2D<>&) { return PropertyType(Rotation2D); }
        static PropertyType getType(const rw::math::VelocityScrew6D<>&) { return PropertyType(VelocityScrew6D); }
        static PropertyType getType(const rw::trajectory::QPath&) { return PropertyType(QPath); }
        static PropertyType getType(const rw::trajectory::Transform3DPath&) { return PropertyType(Transform3DPath); }

        template <class T>
        static PropertyType getType(const T&) { return PropertyType(Unknown); }

    private:
        int _id;
        static int _NextID;
    };



}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp" 2



# 1 "/usr/include/boost-1_41/boost/function.hpp" 1
# 15 "/usr/include/boost-1_41/boost/function.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/iterate.hpp"
#define BOOST_PREPROCESSOR_ITERATE_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/iteration/iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/iteration/iterate.hpp"
#define BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP 



# 1 "/usr/include/boost-1_41/boost/preprocessor/array/elem.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/array/elem.hpp"
#define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/array/data.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/array/data.hpp"
#define BOOST_PREPROCESSOR_ARRAY_DATA_HPP 







#define BOOST_PP_ARRAY_DATA(array) BOOST_PP_TUPLE_ELEM(2, 1, array)
# 16 "/usr/include/boost-1_41/boost/preprocessor/array/elem.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/array/size.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/array/size.hpp"
#define BOOST_PREPROCESSOR_ARRAY_SIZE_HPP 







#define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_TUPLE_ELEM(2, 0, array)
# 17 "/usr/include/boost-1_41/boost/preprocessor/array/elem.hpp" 2






#define BOOST_PP_ARRAY_ELEM(i,array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array))
# 18 "/usr/include/boost-1_41/boost/preprocessor/iteration/iterate.hpp" 2


# 1 "/usr/include/boost-1_41/boost/preprocessor/slot/slot.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/slot/slot.hpp"
#define BOOST_PREPROCESSOR_SLOT_SLOT_HPP 


# 1 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/def.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/def.hpp"
#define BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP 



#define BOOST_PP_SLOT_OFFSET_10(x) (x) % 1000000000UL
#define BOOST_PP_SLOT_OFFSET_9(x) BOOST_PP_SLOT_OFFSET_10(x) % 100000000UL
#define BOOST_PP_SLOT_OFFSET_8(x) BOOST_PP_SLOT_OFFSET_9(x) % 10000000UL
#define BOOST_PP_SLOT_OFFSET_7(x) BOOST_PP_SLOT_OFFSET_8(x) % 1000000UL
#define BOOST_PP_SLOT_OFFSET_6(x) BOOST_PP_SLOT_OFFSET_7(x) % 100000UL
#define BOOST_PP_SLOT_OFFSET_5(x) BOOST_PP_SLOT_OFFSET_6(x) % 10000UL
#define BOOST_PP_SLOT_OFFSET_4(x) BOOST_PP_SLOT_OFFSET_5(x) % 1000UL
#define BOOST_PP_SLOT_OFFSET_3(x) BOOST_PP_SLOT_OFFSET_4(x) % 100UL
#define BOOST_PP_SLOT_OFFSET_2(x) BOOST_PP_SLOT_OFFSET_3(x) % 10UL



#define BOOST_PP_SLOT_CC_2(a,b) BOOST_PP_SLOT_CC_2_D(a, b)
#define BOOST_PP_SLOT_CC_3(a,b,c) BOOST_PP_SLOT_CC_3_D(a, b, c)
#define BOOST_PP_SLOT_CC_4(a,b,c,d) BOOST_PP_SLOT_CC_4_D(a, b, c, d)
#define BOOST_PP_SLOT_CC_5(a,b,c,d,e) BOOST_PP_SLOT_CC_5_D(a, b, c, d, e)
#define BOOST_PP_SLOT_CC_6(a,b,c,d,e,f) BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f)
#define BOOST_PP_SLOT_CC_7(a,b,c,d,e,f,g) BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g)
#define BOOST_PP_SLOT_CC_8(a,b,c,d,e,f,g,h) BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h)
#define BOOST_PP_SLOT_CC_9(a,b,c,d,e,f,g,h,i) BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i)
#define BOOST_PP_SLOT_CC_10(a,b,c,d,e,f,g,h,i,j) BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j)

#define BOOST_PP_SLOT_CC_2_D(a,b) a ## b
#define BOOST_PP_SLOT_CC_3_D(a,b,c) a ## b ## c
#define BOOST_PP_SLOT_CC_4_D(a,b,c,d) a ## b ## c ## d
#define BOOST_PP_SLOT_CC_5_D(a,b,c,d,e) a ## b ## c ## d ## e
#define BOOST_PP_SLOT_CC_6_D(a,b,c,d,e,f) a ## b ## c ## d ## e ## f
#define BOOST_PP_SLOT_CC_7_D(a,b,c,d,e,f,g) a ## b ## c ## d ## e ## f ## g
#define BOOST_PP_SLOT_CC_8_D(a,b,c,d,e,f,g,h) a ## b ## c ## d ## e ## f ## g ## h
#define BOOST_PP_SLOT_CC_9_D(a,b,c,d,e,f,g,h,i) a ## b ## c ## d ## e ## f ## g ## h ## i
#define BOOST_PP_SLOT_CC_10_D(a,b,c,d,e,f,g,h,i,j) a ## b ## c ## d ## e ## f ## g ## h ## i ## j
# 17 "/usr/include/boost-1_41/boost/preprocessor/slot/slot.hpp" 2



#define BOOST_PP_ASSIGN_SLOT(i) BOOST_PP_CAT(BOOST_PP_ASSIGN_SLOT_, i)

#define BOOST_PP_ASSIGN_SLOT_1 <boost/preprocessor/slot/detail/slot1.hpp>
#define BOOST_PP_ASSIGN_SLOT_2 <boost/preprocessor/slot/detail/slot2.hpp>
#define BOOST_PP_ASSIGN_SLOT_3 <boost/preprocessor/slot/detail/slot3.hpp>
#define BOOST_PP_ASSIGN_SLOT_4 <boost/preprocessor/slot/detail/slot4.hpp>
#define BOOST_PP_ASSIGN_SLOT_5 <boost/preprocessor/slot/detail/slot5.hpp>



#define BOOST_PP_SLOT(i) BOOST_PP_CAT(BOOST_PP_SLOT_, i)()
# 21 "/usr/include/boost-1_41/boost/preprocessor/iteration/iterate.hpp" 2




#define BOOST_PP_ITERATION_DEPTH() 0



#define BOOST_PP_ITERATION() BOOST_PP_CAT(BOOST_PP_ITERATION_, BOOST_PP_ITERATION_DEPTH())



#define BOOST_PP_ITERATION_START() BOOST_PP_CAT(BOOST_PP_ITERATION_START_, BOOST_PP_ITERATION_DEPTH())
#define BOOST_PP_ITERATION_FINISH() BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, BOOST_PP_ITERATION_DEPTH())



#define BOOST_PP_ITERATION_FLAGS() (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, BOOST_PP_ITERATION_DEPTH()))



#define BOOST_PP_FRAME_ITERATION(i) BOOST_PP_CAT(BOOST_PP_ITERATION_, i)



#define BOOST_PP_FRAME_START(i) BOOST_PP_CAT(BOOST_PP_ITERATION_START_, i)
#define BOOST_PP_FRAME_FINISH(i) BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, i)



#define BOOST_PP_FRAME_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, i))



#define BOOST_PP_RELATIVE_ITERATION(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_)

#define BOOST_PP_RELATIVE_0(m) BOOST_PP_CAT(m, BOOST_PP_ITERATION_DEPTH())
#define BOOST_PP_RELATIVE_1(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))
#define BOOST_PP_RELATIVE_2(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))
#define BOOST_PP_RELATIVE_3(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))))
#define BOOST_PP_RELATIVE_4(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))))



#define BOOST_PP_RELATIVE_START(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_START_)
#define BOOST_PP_RELATIVE_FINISH(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FINISH_)



#define BOOST_PP_RELATIVE_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FLAGS_))



#define BOOST_PP_ITERATE() BOOST_PP_CAT(BOOST_PP_ITERATE_, BOOST_PP_INC(BOOST_PP_ITERATION_DEPTH()))

#define BOOST_PP_ITERATE_1 <boost/preprocessor/iteration/detail/iter/forward1.hpp>
#define BOOST_PP_ITERATE_2 <boost/preprocessor/iteration/detail/iter/forward2.hpp>
#define BOOST_PP_ITERATE_3 <boost/preprocessor/iteration/detail/iter/forward3.hpp>
#define BOOST_PP_ITERATE_4 <boost/preprocessor/iteration/detail/iter/forward4.hpp>
#define BOOST_PP_ITERATE_5 <boost/preprocessor/iteration/detail/iter/forward5.hpp>
# 16 "/usr/include/boost-1_41/boost/preprocessor/iterate.hpp" 2
# 16 "/usr/include/boost-1_41/boost/function.hpp" 2



#define BOOST_FUNCTION_MAX_ARGS 10




# 1 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 1
# 11 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp"
#define BOOST_FUNCTION_PROLOGUE_HPP 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 1 3
# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3
       
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cassert" 2 3
# 13 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2

# 1 "/usr/include/boost-1_41/boost/config/no_tr1/functional.hpp" 1
# 14 "/usr/include/boost-1_41/boost/config/no_tr1/functional.hpp"
#define BOOST_CONFIG_FUNCTIONAL 


#define BOOST_TR1_NO_RECURSION 
#define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 





#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
# 15 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2


# 1 "/usr/include/boost-1_41/boost/function/function_base.hpp" 1
# 12 "/usr/include/boost-1_41/boost/function/function_base.hpp"
#define BOOST_FUNCTION_BASE_HEADER 







# 1 "/usr/include/boost-1_41/boost/assert.hpp" 1
# 16 "/usr/include/boost-1_41/boost/assert.hpp"
#undef BOOST_ASSERT
# 36 "/usr/include/boost-1_41/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 26 "/usr/include/assert.h" 3 4
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST


#undef assert_perror




#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 66 "/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__));


}

#define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))





#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
# 106 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 37 "/usr/include/boost-1_41/boost/assert.hpp" 2
#define BOOST_ASSERT(expr) assert(expr)


#undef BOOST_VERIFY







#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# 21 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_41/boost/integer.hpp" 1
# 16 "/usr/include/boost-1_41/boost/integer.hpp"
#define BOOST_INTEGER_HPP 

# 1 "/usr/include/boost-1_41/boost/integer_fwd.hpp" 1
# 10 "/usr/include/boost-1_41/boost/integer_fwd.hpp"
#define BOOST_INTEGER_FWD_HPP 

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 3

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4
# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/climits" 2 3
# 13 "/usr/include/boost-1_41/boost/integer_fwd.hpp" 2
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 14 "/usr/include/boost-1_41/boost/integer_fwd.hpp" 2





namespace boost
{
# 30 "/usr/include/boost-1_41/boost/integer_fwd.hpp"
template < class T >
    class integer_traits;

template < >
    class integer_traits< bool >;

template < >
    class integer_traits< char >;

template < >
    class integer_traits< signed char >;

template < >
    class integer_traits< unsigned char >;


template < >
    class integer_traits< wchar_t >;


template < >
    class integer_traits< short >;

template < >
    class integer_traits< unsigned short >;

template < >
    class integer_traits< int >;

template < >
    class integer_traits< unsigned int >;

template < >
    class integer_traits< long >;

template < >
    class integer_traits< unsigned long >;


template < >
    class integer_traits< ::boost::long_long_type>;

template < >
    class integer_traits< ::boost::ulong_long_type >;





template < typename LeastInt >
    struct int_fast_t;

template< int Bits >
    struct int_t;

template< int Bits >
    struct uint_t;

template< long MaxValue >
    struct int_max_value_t;

template< long MinValue >
    struct int_min_value_t;

template< unsigned long Value >
    struct uint_value_t;




template < std::size_t Bit >
    struct high_bit_mask_t;

template < std::size_t Bits >
    struct low_bits_mask_t;

template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;


template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;



template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;



template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;





template < unsigned long Value >
    struct static_log2;

template < >
    struct static_log2< 0ul >;




template < long Value1, long Value2 >
    struct static_signed_min;

template < long Value1, long Value2 >
    struct static_signed_max;

template < unsigned long Value1, unsigned long Value2 >
    struct static_unsigned_min;

template < unsigned long Value1, unsigned long Value2 >
    struct static_unsigned_max;


}
# 19 "/usr/include/boost-1_41/boost/integer.hpp" 2

# 1 "/usr/include/boost-1_41/boost/integer_traits.hpp" 1
# 17 "/usr/include/boost-1_41/boost/integer_traits.hpp"
#define BOOST_INTEGER_TRAITS_HPP 





# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include-fixed/limits.h" 1 3 4
# 24 "/usr/include/boost-1_41/boost/integer_traits.hpp" 2



# 1 "/usr/include/wchar.h" 1 3 4
# 897 "/usr/include/wchar.h" 3 4
#undef __need_mbstate_t
#undef __need_wint_t
# 28 "/usr/include/boost-1_41/boost/integer_traits.hpp" 2



namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};



template<class T, T min_val, T max_val>
const bool integer_traits_base<T, min_val, max_val>::is_integral;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_min;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_max;


}

template<>
class integer_traits<bool>
  : public std::numeric_limits<bool>,
    public detail::integer_traits_base<bool, false, true>
{ };

template<>
class integer_traits<char>
  : public std::numeric_limits<char>,
    public detail::integer_traits_base<char, (-127 - 1), 127>
{ };

template<>
class integer_traits<signed char>
  : public std::numeric_limits<signed char>,
    public detail::integer_traits_base<signed char, (-127 - 1), 127>
{ };

template<>
class integer_traits<unsigned char>
  : public std::numeric_limits<unsigned char>,
    public detail::integer_traits_base<unsigned char, 0, (127 * 2 + 1)>
{ };


template<>
class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,



    public detail::integer_traits_base<wchar_t, (-2147483647 - 1), (2147483647)>
# 119 "/usr/include/boost-1_41/boost/integer_traits.hpp"
{ };


template<>
class integer_traits<short>
  : public std::numeric_limits<short>,
    public detail::integer_traits_base<short, (-32767 - 1), 32767>
{ };

template<>
class integer_traits<unsigned short>
  : public std::numeric_limits<unsigned short>,
    public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
{ };

template<>
class integer_traits<int>
  : public std::numeric_limits<int>,
    public detail::integer_traits_base<int, (-2147483647 - 1), 2147483647>
{ };

template<>
class integer_traits<unsigned int>
  : public std::numeric_limits<unsigned int>,
    public detail::integer_traits_base<unsigned int, 0, (2147483647 * 2U + 1U)>
{ };

template<>
class integer_traits<long>
  : public std::numeric_limits<long>,
    public detail::integer_traits_base<long, (-9223372036854775807L - 1L), 9223372036854775807L>
{ };

template<>
class integer_traits<unsigned long>
  : public std::numeric_limits<unsigned long>,
    public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L * 2UL + 1UL)>
{ };




template<>
class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1), 9223372036854775807LL>
{ };

template<>
class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL * 2ULL + 1)>
{ };
# 231 "/usr/include/boost-1_41/boost/integer_traits.hpp"
}
# 21 "/usr/include/boost-1_41/boost/integer.hpp" 2


namespace boost
{





  template< typename LeastInt >
  struct int_fast_t { typedef LeastInt fast; };


  template< int Category > struct int_least_helper {};




  template<> struct int_least_helper<1> { typedef long least; };
  template<> struct int_least_helper<2> { typedef int least; };
  template<> struct int_least_helper<3> { typedef short least; };
  template<> struct int_least_helper<4> { typedef signed char least; };
  template<> struct int_least_helper<6> { typedef unsigned long least; };
  template<> struct int_least_helper<7> { typedef unsigned int least; };
  template<> struct int_least_helper<8> { typedef unsigned short least; };
  template<> struct int_least_helper<9> { typedef unsigned char least; };




  template< int Bits >
  struct int_t
  {
      typedef typename int_least_helper
        <
          (Bits-1 <= std::numeric_limits<long>::digits) +
          (Bits-1 <= std::numeric_limits<int>::digits) +
          (Bits-1 <= std::numeric_limits<short>::digits) +
          (Bits-1 <= std::numeric_limits<signed char>::digits)
        >::least least;
      typedef typename int_fast_t<least>::fast fast;
  };


  template< int Bits >
  struct uint_t
  {
      typedef typename int_least_helper
        <
          5 +
          (Bits <= std::numeric_limits<unsigned long>::digits) +
          (Bits <= std::numeric_limits<unsigned int>::digits) +
          (Bits <= std::numeric_limits<unsigned short>::digits) +
          (Bits <= std::numeric_limits<unsigned char>::digits)
        >::least least;
      typedef typename int_fast_t<least>::fast fast;

  };




  template< long MaxValue >
  struct int_max_value_t
  {
      typedef typename int_least_helper
        <
          (MaxValue <= integer_traits<long>::const_max) +
          (MaxValue <= integer_traits<int>::const_max) +
          (MaxValue <= integer_traits<short>::const_max) +
          (MaxValue <= integer_traits<signed char>::const_max)
        >::least least;
      typedef typename int_fast_t<least>::fast fast;
  };

  template< long MinValue >
  struct int_min_value_t
  {
      typedef typename int_least_helper
        <
          (MinValue >= integer_traits<long>::const_min) +
          (MinValue >= integer_traits<int>::const_min) +
          (MinValue >= integer_traits<short>::const_min) +
          (MinValue >= integer_traits<signed char>::const_min)
        >::least least;
      typedef typename int_fast_t<least>::fast fast;
  };


  template< unsigned long Value >
  struct uint_value_t
  {
      typedef typename int_least_helper
        <
          5 +
          (Value <= integer_traits<unsigned long>::const_max) +
          (Value <= integer_traits<unsigned int>::const_max) +
          (Value <= integer_traits<unsigned short>::const_max) +
          (Value <= integer_traits<unsigned char>::const_max)
        >::least least;
      typedef typename int_fast_t<least>::fast fast;
  };


}
# 22 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2





# 1 "/usr/include/boost-1_41/boost/type_traits/composite_traits.hpp" 1
# 14 "/usr/include/boost-1_41/boost/type_traits/composite_traits.hpp"
#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED 
# 28 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2

# 1 "/usr/include/boost-1_41/boost/ref.hpp" 1

#define BOOST_REF_HPP_INCLUDED 
# 11 "/usr/include/boost-1_41/boost/ref.hpp"
# 1 "/usr/include/boost-1_41/boost/utility/addressof.hpp" 1
# 13 "/usr/include/boost-1_41/boost/utility/addressof.hpp"
#define BOOST_UTILITY_ADDRESSOF_HPP 




namespace boost
{

namespace detail
{

template<class T> struct addr_impl_ref
{
    T & v_;

    inline addr_impl_ref( T & v ): v_( v ) {}
    inline operator T& () const { return v_; }

private:
    addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T> struct addressof_impl
{
    static inline T * f( T & v, long )
    {
        return reinterpret_cast<T*>(
            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
    }

    static inline T * f( T * v, int )
    {
        return v;
    }
};

}

template<class T> T * addressof( T & v )
{






    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );


}
# 100 "/usr/include/boost-1_41/boost/utility/addressof.hpp"
}
# 12 "/usr/include/boost-1_41/boost/ref.hpp" 2
# 29 "/usr/include/boost-1_41/boost/ref.hpp"
namespace boost
{

template<class T> class reference_wrapper
{
public:
    typedef T type;







    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}



    operator T& () const { return *t_; }

    T& get() const { return *t_; }

    T* get_pointer() const { return t_; }

private:

    T* t_;
};




#define BOOST_REF_CONST const


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

#undef BOOST_REF_CONST



template<typename T>
class is_reference_wrapper
    : public mpl::false_
{
};

template<typename T>
class unwrap_reference
{
 public:
    typedef T type;
};

#define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) template<typename T> class is_reference_wrapper< X > : public mpl::true_ { }; template<typename T> class unwrap_reference< X > { public: typedef T type; };
# 106 "/usr/include/boost-1_41/boost/ref.hpp"
template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };

template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };


#undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
# 176 "/usr/include/boost-1_41/boost/ref.hpp"
template <class T> inline typename unwrap_reference<T>::type&
unwrap_ref(T& t)
{
    return t;
}

template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
{
    return r.get_pointer();
}

}
# 30 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2
# 38 "/usr/include/boost-1_41/boost/function/function_base.hpp"
# 1 "/usr/include/boost-1_41/boost/function_equal.hpp" 1
# 11 "/usr/include/boost-1_41/boost/function_equal.hpp"
#define BOOST_FUNCTION_EQUAL_HPP 

namespace boost {

template<typename F, typename G>
  bool function_equal_impl(const F& f, const G& g, long)
  { return f == g; }




template<typename F, typename G>
  bool function_equal(const F& f, const G& g)
  { return function_equal_impl(f, g, 0); }

}
# 39 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2
# 1 "/usr/include/boost-1_41/boost/function/function_fwd.hpp" 1
# 10 "/usr/include/boost-1_41/boost/function/function_fwd.hpp"
#define BOOST_FUNCTION_FWD_HPP 
# 28 "/usr/include/boost-1_41/boost/function/function_fwd.hpp"
namespace boost {
  class bad_function_call;



  template<typename Signature> class function;

  template<typename Signature>
  inline void swap(function<Signature>& f1, function<Signature>& f2)
  {
    f1.swap(f2);
  }



  template<typename R> class function0;
  template<typename R, typename T1> class function1;
  template<typename R, typename T1, typename T2> class function2;
  template<typename R, typename T1, typename T2, typename T3> class function3;
  template<typename R, typename T1, typename T2, typename T3, typename T4>
    class function4;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5>
    class function5;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6>
    class function6;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7>
    class function7;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8>
    class function8;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9>
    class function9;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9,
           typename T10>
    class function10;
}
# 40 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2
# 52 "/usr/include/boost-1_41/boost/function/function_base.hpp"
#define BOOST_FUNCTION_STD_NS std







# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 1 3
# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3
       
# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstddef" 2 3
# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 2 3
# 1 "/usr/include/string.h" 1 3 4
# 24 "/usr/include/string.h" 3 4
#define _STRING_H 1



extern "C" {


#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 1 3 4
# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_ptrdiff_t
# 233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_size_t
# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_wchar_t
# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/stddef.h" 3 4
#undef __need_NULL




#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
# 34 "/usr/include/string.h" 2 3 4



#define __CORRECT_ISO_CPP_STRING_H_PROTO 





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


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






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const void *memchr (__const void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 92 "/usr/include/string.h" 3 4
}










extern "C++" void *rawmemchr (void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const void *rawmemchr (__const void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (2)));

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




#define strdupa(s) (__extension__ ({ __const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
# 197 "/usr/include/string.h" 3 4
#define strndupa(s,n) (__extension__ ({ __const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
# 208 "/usr/include/string.h" 3 4



extern "C++"
{
extern char *strchr (char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *strchr (__const char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 231 "/usr/include/string.h" 3 4
}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *strrchr (__const char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 258 "/usr/include/string.h" 3 4
}










extern "C++" char *strchrnul (char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" __const char *strchrnul (__const char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, __const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __const char *strpbrk (__const char *__s, __const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 310 "/usr/include/string.h" 3 4
}






extern "C++"
{
extern char *strstr (char *__haystack, __const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __const char *strstr (__const char *__haystack,
        __const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 338 "/usr/include/string.h" 3 4
}







extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
    __const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, __const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" __const char *strcasestr (__const char *__haystack,
           __const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 380 "/usr/include/string.h" 3 4
extern void *memmem (__const void *__haystack, size_t __haystacklen,
       __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



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





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





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





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

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



extern "C++"
{
extern char *index (char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *index (__const char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 485 "/usr/include/string.h" 3 4
}







extern "C++"
{
extern char *rindex (char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __const char *rindex (__const char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 513 "/usr/include/string.h" 3 4
}







extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));




extern int strcasecmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
    __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
     size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
       __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));







extern "C++" char *basename (char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" __const char *basename (__const char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 644 "/usr/include/string.h" 3 4
}
# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 2 3


#define _GLIBCXX_CSTRING 1


#undef memchr
#undef memcmp
#undef memcpy
#undef memmove
#undef memset
#undef strcat
#undef strchr
#undef strcmp
#undef strcoll
#undef strcpy
#undef strcspn
#undef strerror
#undef strlen
#undef strncat
#undef strncmp
#undef strncpy
#undef strpbrk
#undef strrchr
#undef strspn
#undef strstr
#undef strtok
#undef strxfrm

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

  using ::memchr;
  using ::memcmp;
  using ::memcpy;
  using ::memmove;
  using ::memset;
  using ::strcat;
  using ::strcmp;
  using ::strcoll;
  using ::strcpy;
  using ::strcspn;
  using ::strerror;
  using ::strlen;
  using ::strncat;
  using ::strncmp;
  using ::strncpy;
  using ::strspn;
  using ::strtok;
  using ::strxfrm;
  using ::strchr;
  using ::strpbrk;
  using ::strrchr;
  using ::strstr;
# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/cstring" 3
}
# 61 "/usr/include/boost-1_41/boost/function/function_base.hpp" 2
#define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) (std::strcmp((X).name(),(Y).name()) == 0)
# 70 "/usr/include/boost-1_41/boost/function/function_base.hpp"
#define BOOST_FUNCTION_TARGET_FIX(x) 



#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), Type>::type
# 87 "/usr/include/boost-1_41/boost/function/function_base.hpp"
namespace boost {
  namespace detail {
    namespace function {
      class X;







      union function_buffer
      {

        mutable void* obj_ptr;


        struct type_t {

          const std::type_info* type;


          bool const_qualified;

          bool volatile_qualified;
        } type;


        mutable void (*func_ptr)();


        struct bound_memfunc_ptr_t {
          void (X::*memfunc_ptr)(int);
          void* obj_ptr;
        } bound_memfunc_ptr;



        struct obj_ref_t {
          mutable void* obj_ptr;
          bool is_const_qualified;
          bool is_volatile_qualified;
        } obj_ref;


        mutable char data;
      };







      struct unusable
      {
        unusable() {}
        template<typename T> unusable(const T&) {}
      };





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

      template<>
      struct function_return_type<void>
      {
        typedef unusable type;
      };


      enum functor_manager_operation_type {
        clone_functor_tag,
        move_functor_tag,
        destroy_functor_tag,
        check_functor_type_tag,
        get_functor_type_tag
      };


      struct function_ptr_tag {};
      struct function_obj_tag {};
      struct member_ptr_tag {};
      struct function_obj_ref_tag {};

      template<typename F>
      class get_function_tag
      {
        typedef typename mpl::if_c<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;

        typedef typename mpl::if_c<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;

      public:
        typedef or_ref_tag type;
      };



      template<typename F>
      struct reference_manager
      {
        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          switch (op) {
          case clone_functor_tag:
            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
            return;

          case move_functor_tag:
            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
            in_buffer.obj_ref.obj_ptr = 0;
            return;

          case destroy_functor_tag:
            out_buffer.obj_ref.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {
              const std::type_info& check_type
                = *out_buffer.type.type;



              if ((std::strcmp((check_type).name(),(typeid(F)).name()) == 0)
                  && (!in_buffer.obj_ref.is_const_qualified
                      || out_buffer.type.const_qualified)
                  && (!in_buffer.obj_ref.is_volatile_qualified
                      || out_buffer.type.volatile_qualified))
                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
              else
                out_buffer.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
            out_buffer.type.type = &typeid(F);
            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
          }
        }
      };





      template<typename F>
      struct function_allows_small_object_optimization
      {
        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)));




      };

      template <typename F,typename A>
      struct functor_wrapper: public F, public A
      {
        functor_wrapper( F f, A a ):
          F(f),
          A(a)
        {
        }

 functor_wrapper(const functor_wrapper& f) :
          F(static_cast<const F&>(f)),
          A(static_cast<const A&>(f))
 {
 }
      };





      template<typename Functor>
      struct functor_manager_common
      {
        typedef Functor functor_type;


        static inline void
        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
            out_buffer.func_ptr = in_buffer.func_ptr;
          else if (op == move_functor_tag) {
            out_buffer.func_ptr = in_buffer.func_ptr;
            in_buffer.func_ptr = 0;
          } else if (op == destroy_functor_tag)
            out_buffer.func_ptr = 0;
          else if (op == check_functor_type_tag) {
            const std::type_info& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }


        static inline void
        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor =
              reinterpret_cast<const functor_type*>(&in_buffer.data);
            new ((void*)&out_buffer.data) functor_type(*in_functor);

            if (op == move_functor_tag) {
              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
            }
          } else if (op == destroy_functor_tag) {

            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
          } else if (op == check_functor_type_tag) {
            const std::type_info& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = &in_buffer.data;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }
      };

      template<typename Functor>
      struct functor_manager
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {



            const functor_type* f =
              (const functor_type*)(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.obj_ptr = in_buffer.obj_ptr;
            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_type* f =
              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            const std::type_info& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, member_ptr_tag)
        {
          manager(in_buffer, out_buffer, op, mpl::true_());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.type.type = &typeid(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };

      template<typename Functor, typename Allocator>
      struct functor_manager_a
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;

          if (op == clone_functor_tag) {



            const functor_wrapper_type* f =
              (const functor_wrapper_type*)(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
            wrapper_allocator.construct(copy, *f);


            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.obj_ptr = in_buffer.obj_ptr;
            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_wrapper_type* victim =
              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
            wrapper_allocator.destroy(victim);
            wrapper_allocator.deallocate(victim,1);
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            const std::type_info& check_type
              = *out_buffer.type.type;
            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else {
            out_buffer.type.type = &typeid(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.type.type = &typeid(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };


      struct useless_clear_type {};
# 607 "/usr/include/boost-1_41/boost/function/function_base.hpp"
      struct vtable_base
      {
        void (*manager)(const function_buffer& in_buffer,
                        function_buffer& out_buffer,
                        functor_manager_operation_type op);
      };
    }
  }







class function_base
{
public:
  function_base() : vtable(0) { }


  bool empty() const { return !vtable; }



  const std::type_info& target_type() const
  {
    if (!vtable) return typeid(void);

    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
    return *type.type.type;
  }

  template<typename Functor>
    Functor* target()
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.type.type = &typeid(Functor);
      type_result.type.const_qualified = is_const<Functor>::value;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);
      return static_cast<Functor*>(type_result.obj_ptr);
    }

  template<typename Functor>



    const Functor* target() const

    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.type.type = &typeid(Functor);
      type_result.type.const_qualified = true;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);


      return (const Functor*)(type_result.obj_ptr);
    }

  template<typename F>
    bool contains(const F& f) const
    {



      if (const F* fp = this->template target<F>())

      {
        return function_equal(*fp, f);
      } else {
        return false;
      }
    }
# 713 "/usr/include/boost-1_41/boost/function/function_base.hpp"
public:
  detail::function::vtable_base* get_vtable() const {
    return reinterpret_cast<detail::function::vtable_base*>(
             reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
  }

  bool has_trivial_copy_and_destroy() const {
    return reinterpret_cast<std::size_t>(vtable) & 0x01;
  }

  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
};





class bad_function_call : public std::runtime_error
{
public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
};


inline bool operator==(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return f.empty();
}

inline bool operator!=(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return !f.empty();
}

inline bool operator==(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return f.empty();
}

inline bool operator!=(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return !f.empty();
}
# 798 "/usr/include/boost-1_41/boost/function/function_base.hpp"
template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(*fp, g);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(g, *fp);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(*fp, g);
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(g, *fp);
    else return true;
  }


template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp == g.get_pointer();
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator==(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() == fp;
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp != g.get_pointer();
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
  operator!=(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() != fp;
    else return true;
  }



namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
    {
      return f->empty();
    }







    inline bool has_empty_target(...)
    {
      return false;
    }

  }
}
}

#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
# 18 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_41/boost/mem_fn.hpp" 1

#define BOOST_MEM_FN_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/mem_fn.hpp"
# 1 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp" 1

#define BOOST_BIND_MEM_FN_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp"
# 1 "/usr/include/boost-1_41/boost/get_pointer.hpp" 1





#define GET_POINTER_DWA20021219_HPP 







namespace boost {



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



template<class T> T * get_pointer(std::auto_ptr<T> const& p)
{
    return p.get();
}


}
# 26 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp" 2


namespace boost
{
# 204 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp"
#define BOOST_MEM_FN_CLASS_F 
#define BOOST_MEM_FN_TYPEDEF(X) typedef X;

namespace _mfi
{

#define BOOST_MEM_FN_RETURN return

#define BOOST_MEM_FN_NAME(X) X
#define BOOST_MEM_FN_CC 

# 1 "/usr/include/boost-1_41/boost/bind/mem_fn_template.hpp" 1
# 16 "/usr/include/boost-1_41/boost/bind/mem_fn_template.hpp"
#define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS 




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

#undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
# 216 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp" 2

#undef BOOST_MEM_FN_CC
#undef BOOST_MEM_FN_NAME
# 256 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp"
#undef BOOST_MEM_FN_RETURN

}

#undef BOOST_MEM_FN_CLASS_F
#undef BOOST_MEM_FN_TYPEDEF



#define BOOST_MEM_FN_NAME(X) X
#define BOOST_MEM_FN_CC 

# 1 "/usr/include/boost-1_41/boost/bind/mem_fn_cc.hpp" 1
# 15 "/usr/include/boost-1_41/boost/bind/mem_fn_cc.hpp"
template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
{
    return _mfi::mf0<R, T>(f);
}

template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
{
    return _mfi::cmf0<R, T>(f);
}

template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
{
    return _mfi::mf1<R, T, A1>(f);
}

template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
{
    return _mfi::cmf1<R, T, A1>(f);
}

template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
{
    return _mfi::mf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
{
    return _mfi::cmf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
{
    return _mfi::mf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
{
    return _mfi::cmf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
{
    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
{
    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
{
    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
{
    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
{
    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
{
    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
{
    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
{
    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
{
    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
# 269 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp" 2

#undef BOOST_MEM_FN_NAME
#undef BOOST_MEM_FN_CC
# 311 "/usr/include/boost-1_41/boost/bind/mem_fn.hpp"
namespace _mfi
{

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:

    typedef R (T::*F);
    F f_;

    template<class U> R const & call(U & u, T const *) const
    {
        return (u.*f_);
    }

    template<class U> R const & call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_);
    }

public:

    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U const & u) const
    {
        return call(u, &u);
    }



    R & operator()(T & t) const
    {
        return (t.*f_);
    }

    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }



    bool operator==(dm const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(dm const & rhs) const
    {
        return f_ != rhs.f_;
    }
};

}

template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
    return _mfi::dm<R, T>(f);
}

}
# 23 "/usr/include/boost-1_41/boost/mem_fn.hpp" 2
# 19 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2

# 1 "/usr/include/boost-1_41/boost/preprocessor/enum.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/enum.hpp"
#define BOOST_PREPROCESSOR_ENUM_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum.hpp"
#define BOOST_PREPROCESSOR_REPETITION_ENUM_HPP 




# 1 "/usr/include/boost-1_41/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum.hpp" 2
# 32 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum.hpp"
#define BOOST_PP_ENUM BOOST_PP_CAT(BOOST_PP_ENUM_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))


#define BOOST_PP_ENUM_1(c,m,d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d))
#define BOOST_PP_ENUM_2(c,m,d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d))
#define BOOST_PP_ENUM_3(c,m,d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d))
# 47 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum.hpp"
#define BOOST_PP_ENUM_4(c,m,d) BOOST_PP_ERROR(0x0003)


#define BOOST_PP_ENUM_M_1(z,n,md) BOOST_PP_ENUM_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
#define BOOST_PP_ENUM_M_2(z,n,md) BOOST_PP_ENUM_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
#define BOOST_PP_ENUM_M_3(z,n,md) BOOST_PP_ENUM_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
#define BOOST_PP_ENUM_M_1_IM(z,n,im) BOOST_PP_ENUM_M_1_I(z, n, im)
#define BOOST_PP_ENUM_M_2_IM(z,n,im) BOOST_PP_ENUM_M_2_I(z, n, im)
#define BOOST_PP_ENUM_M_3_IM(z,n,im) BOOST_PP_ENUM_M_3_I(z, n, im)






#define BOOST_PP_ENUM_M_1_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
#define BOOST_PP_ENUM_M_2_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
#define BOOST_PP_ENUM_M_3_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
# 16 "/usr/include/boost-1_41/boost/preprocessor/enum.hpp" 2
# 21 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2
# 1 "/usr/include/boost-1_41/boost/preprocessor/enum_params.hpp" 1
# 13 "/usr/include/boost-1_41/boost/preprocessor/enum_params.hpp"
#define BOOST_PREPROCESSOR_ENUM_PARAMS_HPP 

# 1 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum_params.hpp" 1
# 15 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum_params.hpp"
#define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP 
# 24 "/usr/include/boost-1_41/boost/preprocessor/repetition/enum_params.hpp"
#define BOOST_PP_ENUM_PARAMS(count,param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param)





#define BOOST_PP_ENUM_PARAMS_M(z,n,param) BOOST_PP_COMMA_IF(n) param ## n




#define BOOST_PP_ENUM_PARAMS_Z(z,count,param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param)
# 16 "/usr/include/boost-1_41/boost/preprocessor/enum_params.hpp" 2
# 22 "/usr/include/boost-1_41/boost/function/detail/prologue.hpp" 2
# 25 "/usr/include/boost-1_41/boost/function.hpp" 2
# 63 "/usr/include/boost-1_41/boost/function.hpp"
#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
# 1 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 23 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp"
#define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_1)
# 1 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp" 1
# 16 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#undef BOOST_PP_SLOT_TEMP_1
#undef BOOST_PP_SLOT_TEMP_2
#undef BOOST_PP_SLOT_TEMP_3
#undef BOOST_PP_SLOT_TEMP_4
#undef BOOST_PP_SLOT_TEMP_5
#undef BOOST_PP_SLOT_TEMP_6
#undef BOOST_PP_SLOT_TEMP_7
#undef BOOST_PP_SLOT_TEMP_8
#undef BOOST_PP_SLOT_TEMP_9
#undef BOOST_PP_SLOT_TEMP_10


#define BOOST_PP_SLOT_TEMP_10 0
# 50 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_9 0
# 72 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_8 0
# 94 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_7 0
# 116 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_6 0
# 138 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_5 0
# 160 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_4 0
# 182 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_3 0
# 204 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_2 0
# 226 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_1 0
# 247 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#undef BOOST_PP_VALUE
# 13 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2

#undef BOOST_PP_ITERATION_START_1

#undef BOOST_PP_ITERATION_START_1_DIGIT_1
#undef BOOST_PP_ITERATION_START_1_DIGIT_2
#undef BOOST_PP_ITERATION_START_1_DIGIT_3
#undef BOOST_PP_ITERATION_START_1_DIGIT_4
#undef BOOST_PP_ITERATION_START_1_DIGIT_5
#undef BOOST_PP_ITERATION_START_1_DIGIT_6
#undef BOOST_PP_ITERATION_START_1_DIGIT_7
#undef BOOST_PP_ITERATION_START_1_DIGIT_8
#undef BOOST_PP_ITERATION_START_1_DIGIT_9
#undef BOOST_PP_ITERATION_START_1_DIGIT_10


#define BOOST_PP_ITERATION_START_1_DIGIT_3 0
# 50 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
#define BOOST_PP_ITERATION_START_1_DIGIT_2 0
# 72 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
#define BOOST_PP_ITERATION_START_1_DIGIT_1 0
# 98 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
#define BOOST_PP_ITERATION_START_1 BOOST_PP_ITERATION_START_1_DIGIT_1
# 25 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_1)
# 1 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp" 1
# 16 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#undef BOOST_PP_SLOT_TEMP_1
#undef BOOST_PP_SLOT_TEMP_2
#undef BOOST_PP_SLOT_TEMP_3
#undef BOOST_PP_SLOT_TEMP_4
#undef BOOST_PP_SLOT_TEMP_5
#undef BOOST_PP_SLOT_TEMP_6
#undef BOOST_PP_SLOT_TEMP_7
#undef BOOST_PP_SLOT_TEMP_8
#undef BOOST_PP_SLOT_TEMP_9
#undef BOOST_PP_SLOT_TEMP_10


#define BOOST_PP_SLOT_TEMP_10 0
# 50 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_9 0
# 72 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_8 0
# 94 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_7 0
# 116 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_6 0
# 138 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_5 0
# 160 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_4 0
# 182 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_3 0
# 206 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_2 1
# 226 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#define BOOST_PP_SLOT_TEMP_1 0
# 247 "/usr/include/boost-1_41/boost/preprocessor/slot/detail/shared.hpp"
#undef BOOST_PP_VALUE
# 13 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2

#undef BOOST_PP_ITERATION_FINISH_1

#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_1
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_2
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_3
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_4
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_5
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_6
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_7
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_8
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_9
#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_10


#define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 0
# 52 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
#define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 1
# 72 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
#define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 0
# 96 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
#define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1)
# 27 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#define BOOST_PP_FILENAME_1 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_1)



#define BOOST_PP_ITERATION_FLAGS_1 0





#undef BOOST_PP_ITERATION_DEPTH
#define BOOST_PP_ITERATION_DEPTH() 1

#define BOOST_PP_IS_ITERATING 1





#define BOOST_PP_ITERATION_1 0
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 12 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_0 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 14 "/usr/include/boost-1_41/boost/function/function_template.hpp"
# 1 "/usr/include/boost-1_41/boost/detail/no_exceptions_support.hpp" 1

#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ 
# 70 "/usr/include/boost-1_41/boost/detail/no_exceptions_support.hpp"
#define BOOST_TRY { try
#define BOOST_CATCH(x) catch(x)
#define BOOST_RETHROW throw;
#define BOOST_CATCH_END }
# 15 "/usr/include/boost-1_41/boost/function/function_template.hpp" 2






#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)



#define BOOST_FUNCTION_COMMA 





#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R
       
        >
      struct function_invoker0
      {
        static R invoke(function_buffer& function_ptr
                        )
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f();
        }
      };

      template<
        typename FunctionPtr,
        typename R
       
        >
      struct void_function_invoker0
      {
        static void
        invoke(function_buffer& function_ptr
               )

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_obj_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_obj_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_ref_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_ref_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)();
        }
      };
# 230 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<
        typename FunctionPtr,
        typename R
       
      >
      struct get_function_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker0<
                            FunctionPtr,
                            R
                           
                          >,
                          function_invoker0<
                            FunctionPtr,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_obj_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_ref_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker0 { };


      template<>
      struct get_invoker0<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R >
        struct apply
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };
# 400 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<>
      struct get_invoker0<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R >
        struct apply
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker0<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R >
        struct apply
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R >
      struct basic_vtable0
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                           
                                            );

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }
# 562 "/usr/include/boost-1_41/boost/function/function_template.hpp"
        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R
   
  >
  class function0 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable0<
              R >
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 0;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 0;
   

    typedef function0 self_type;

    function0() : function_base() { }



    template<typename Functor>
    function0(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function0(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function0(clear_type*) : function_base() { }







    function0(const function0& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function0() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()() const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function0&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function0& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function0& operator=(const function0& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function0& other)
    {
      if (&other == this)
        return;

      function0 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function0& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R
                        >
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R
                         ,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function0& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R >
  inline void swap(function0<
                     R
                    
                   >& f1,
                   function0<
                     R
                    
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R >
  typename function0<
      R >::result_type
  inline
  function0<R >
  ::operator()() const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor );
  }



template<typename R >
  void operator==(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >&);
template<typename R >
  void operator!=(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >& );




#define BOOST_FUNCTION_PARTIAL_SPEC R (void)




template<typename R
         >
class function<R (void)>
  : public function0<R >
{
  typedef function0<R > base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 14 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 48 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 1
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 17 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_1 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0
        >
      struct function_invoker1
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0
        >
      struct void_function_invoker1
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct function_obj_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct void_function_obj_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct function_ref_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct void_function_ref_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0
      >
      struct function_mem_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0
      >
      struct function_void_mem_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0
      >
      struct get_function_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker1<
                            FunctionPtr,
                            R ,
                            T0
                          >,
                          function_invoker1<
                            FunctionPtr,
                            R ,
                            T0
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
       >
      struct get_function_obj_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >,
                          function_obj_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
       >
      struct get_function_ref_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >,
                          function_ref_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0
       >
      struct get_member_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker1<
                            MemberPtr,
                            R ,
                            T0
                          >,
                          function_mem_invoker1<
                            MemberPtr,
                            R ,
                            T0
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker1 { };


      template<>
      struct get_invoker1<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_invoker1<
                             FunctionPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker1<
                             FunctionPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker1<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_member_invoker1<
                             MemberPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker1<
                             MemberPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker1<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_obj_invoker1<
                             FunctionObj,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker1<
                             FunctionObj,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker1<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_ref_invoker1<
                             typename RefWrapper::type,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker1<
                             typename RefWrapper::type,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0>
      struct basic_vtable1
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0
  >
  class function1 : public function_base



    , public std::unary_function<T0,R>







  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable1<
              R , T0>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 1;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };


    typedef T0 argument_type;





    static const int arity = 1;
    typedef T0 arg1_type;

    typedef function1 self_type;

    function1() : function_base() { }



    template<typename Functor>
    function1(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function1(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function1(clear_type*) : function_base() { }







    function1(const function1& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function1() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function1&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function1& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function1& operator=(const function1& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function1& other)
    {
      if (&other == this)
        return;

      function1 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function1& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker1<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker1<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function1& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0>
  inline void swap(function1<
                     R ,
                     T0
                   >& f1,
                   function1<
                     R ,
                     T0
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0>
  typename function1<
      R , T0>::result_type
  inline
  function1<R , T0>
  ::operator()( T0 a0) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0);
  }



template<typename R , typename T0>
  void operator==(const function1<
                          R ,
                          T0>&,
                  const function1<
                          R ,
                          T0>&);
template<typename R , typename T0>
  void operator!=(const function1<
                          R ,
                          T0>&,
                  const function1<
                          R ,
                          T0>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0>
class function<R ( T0)>
  : public function1<R , T0>
{
  typedef function1<R , T0> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 19 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 53 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 2
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 22 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_2 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct function_invoker2
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct void_function_invoker2
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_obj_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_obj_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_ref_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_ref_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_mem_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_void_mem_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct get_function_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >,
                          function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_obj_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_ref_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
       >
      struct get_member_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >,
                          function_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker2 { };


      template<>
      struct get_invoker2<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker2<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1>
      struct basic_vtable2
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1
  >
  class function2 : public function_base







    , public std::binary_function<T0,T1,R>



  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable2<
              R , T0 , T1>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 2;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };




    typedef T0 first_argument_type;
    typedef T1 second_argument_type;


    static const int arity = 2;
    typedef T0 arg1_type; typedef T1 arg2_type;

    typedef function2 self_type;

    function2() : function_base() { }



    template<typename Functor>
    function2(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function2(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function2(clear_type*) : function_base() { }







    function2(const function2& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function2() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function2&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function2& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function2& operator=(const function2& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function2& other)
    {
      if (&other == this)
        return;

      function2 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function2& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function2& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1>
  inline void swap(function2<
                     R ,
                     T0 , T1
                   >& f1,
                   function2<
                     R ,
                     T0 , T1
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1>
  typename function2<
      R , T0 , T1>::result_type
  inline
  function2<R , T0 , T1>
  ::operator()( T0 a0 , T1 a1) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1);
  }



template<typename R , typename T0 , typename T1>
  void operator==(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>&);
template<typename R , typename T0 , typename T1>
  void operator!=(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1>
class function<R ( T0 , T1)>
  : public function2<R , T0 , T1>
{
  typedef function2<R , T0 , T1> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 24 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 58 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 3
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 27 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_3 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
        >
      struct function_invoker3
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
        >
      struct void_function_invoker3
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_obj_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct void_function_obj_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_ref_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct void_function_ref_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_mem_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_void_mem_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct get_function_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker3<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_invoker3<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_function_obj_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_obj_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_function_ref_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_ref_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_member_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker3<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_mem_invoker3<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker3 { };


      template<>
      struct get_invoker3<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_invoker3<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker3<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker3<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_member_invoker3<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker3<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker3<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_obj_invoker3<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker3<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker3<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_ref_invoker3<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker3<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2>
      struct basic_vtable3
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2
  >
  class function3 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable3<
              R , T0 , T1 , T2>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 3;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 3;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;

    typedef function3 self_type;

    function3() : function_base() { }



    template<typename Functor>
    function3(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function3(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function3(clear_type*) : function_base() { }







    function3(const function3& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function3() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function3&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function3& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function3& operator=(const function3& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function3& other)
    {
      if (&other == this)
        return;

      function3 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function3& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker3<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker3<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function3& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2>
  inline void swap(function3<
                     R ,
                     T0 , T1 , T2
                   >& f1,
                   function3<
                     R ,
                     T0 , T1 , T2
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2>
  typename function3<
      R , T0 , T1 , T2>::result_type
  inline
  function3<R , T0 , T1 , T2>
  ::operator()( T0 a0 , T1 a1 , T2 a2) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2);
  }



template<typename R , typename T0 , typename T1 , typename T2>
  void operator==(const function3<
                          R ,
                          T0 , T1 , T2>&,
                  const function3<
                          R ,
                          T0 , T1 , T2>&);
template<typename R , typename T0 , typename T1 , typename T2>
  void operator!=(const function3<
                          R ,
                          T0 , T1 , T2>&,
                  const function3<
                          R ,
                          T0 , T1 , T2>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2>
class function<R ( T0 , T1 , T2)>
  : public function3<R , T0 , T1 , T2>
{
  typedef function3<R , T0 , T1 , T2> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 29 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 63 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 4
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 32 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_4 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
        >
      struct function_invoker4
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
        >
      struct void_function_invoker4
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_obj_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct void_function_obj_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_ref_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct void_function_ref_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_mem_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_void_mem_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct get_function_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker4<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_invoker4<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_function_obj_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_obj_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_function_ref_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_ref_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_member_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker4<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_mem_invoker4<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker4 { };


      template<>
      struct get_invoker4<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_invoker4<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker4<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker4<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_member_invoker4<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker4<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker4<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_obj_invoker4<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker4<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker4<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_ref_invoker4<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker4<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
      struct basic_vtable4
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3
  >
  class function4 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable4<
              R , T0 , T1 , T2 , T3>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 4;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 4;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;

    typedef function4 self_type;

    function4() : function_base() { }



    template<typename Functor>
    function4(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function4(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function4(clear_type*) : function_base() { }







    function4(const function4& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function4() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function4&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function4& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function4& operator=(const function4& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function4& other)
    {
      if (&other == this)
        return;

      function4 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function4& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker4<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker4<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function4& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  inline void swap(function4<
                     R ,
                     T0 , T1 , T2 , T3
                   >& f1,
                   function4<
                     R ,
                     T0 , T1 , T2 , T3
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  typename function4<
      R , T0 , T1 , T2 , T3>::result_type
  inline
  function4<R , T0 , T1 , T2 , T3>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  void operator==(const function4<
                          R ,
                          T0 , T1 , T2 , T3>&,
                  const function4<
                          R ,
                          T0 , T1 , T2 , T3>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  void operator!=(const function4<
                          R ,
                          T0 , T1 , T2 , T3>&,
                  const function4<
                          R ,
                          T0 , T1 , T2 , T3>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3>
class function<R ( T0 , T1 , T2 , T3)>
  : public function4<R , T0 , T1 , T2 , T3>
{
  typedef function4<R , T0 , T1 , T2 , T3> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 34 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 68 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 5
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 37 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_5 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
        >
      struct function_invoker5
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
        >
      struct void_function_invoker5
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_obj_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct void_function_obj_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_ref_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct void_function_ref_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_mem_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_void_mem_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct get_function_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker5<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_invoker5<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_function_obj_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_obj_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_function_ref_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_ref_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_member_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker5<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_mem_invoker5<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker5 { };


      template<>
      struct get_invoker5<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_invoker5<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker5<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker5<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_member_invoker5<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker5<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker5<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_obj_invoker5<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker5<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker5<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_ref_invoker5<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker5<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
      struct basic_vtable5
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4
  >
  class function5 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable5<
              R , T0 , T1 , T2 , T3 , T4>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 5;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 5;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;

    typedef function5 self_type;

    function5() : function_base() { }



    template<typename Functor>
    function5(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function5(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function5(clear_type*) : function_base() { }







    function5(const function5& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function5() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function5&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function5& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function5& operator=(const function5& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function5& other)
    {
      if (&other == this)
        return;

      function5 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function5& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker5<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker5<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function5& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  inline void swap(function5<
                     R ,
                     T0 , T1 , T2 , T3 , T4
                   >& f1,
                   function5<
                     R ,
                     T0 , T1 , T2 , T3 , T4
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  typename function5<
      R , T0 , T1 , T2 , T3 , T4>::result_type
  inline
  function5<R , T0 , T1 , T2 , T3 , T4>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  void operator==(const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&,
                  const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  void operator!=(const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&,
                  const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
class function<R ( T0 , T1 , T2 , T3 , T4)>
  : public function5<R , T0 , T1 , T2 , T3 , T4>
{
  typedef function5<R , T0 , T1 , T2 , T3 , T4> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 39 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 73 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 6
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 42 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_6 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
        >
      struct function_invoker6
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
        >
      struct void_function_invoker6
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_obj_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct void_function_obj_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_ref_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct void_function_ref_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_mem_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_void_mem_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct get_function_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker6<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_invoker6<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_function_obj_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_obj_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_function_ref_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_ref_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_member_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker6<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_mem_invoker6<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker6 { };


      template<>
      struct get_invoker6<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_invoker6<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker6<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker6<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_member_invoker6<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker6<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker6<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_obj_invoker6<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker6<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker6<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_ref_invoker6<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker6<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
      struct basic_vtable6
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
  >
  class function6 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable6<
              R , T0 , T1 , T2 , T3 , T4 , T5>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 6;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 6;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;

    typedef function6 self_type;

    function6() : function_base() { }



    template<typename Functor>
    function6(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function6(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function6(clear_type*) : function_base() { }







    function6(const function6& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function6() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function6&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function6& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function6& operator=(const function6& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function6& other)
    {
      if (&other == this)
        return;

      function6 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function6& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker6<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker6<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function6& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  inline void swap(function6<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5
                   >& f1,
                   function6<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  typename function6<
      R , T0 , T1 , T2 , T3 , T4 , T5>::result_type
  inline
  function6<R , T0 , T1 , T2 , T3 , T4 , T5>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4 , a5);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  void operator==(const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&,
                  const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  void operator!=(const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&,
                  const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5)>
  : public function6<R , T0 , T1 , T2 , T3 , T4 , T5>
{
  typedef function6<R , T0 , T1 , T2 , T3 , T4 , T5> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 44 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 78 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 7
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 47 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_7 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
        >
      struct function_invoker7
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
        >
      struct void_function_invoker7
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_obj_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct void_function_obj_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_ref_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct void_function_ref_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_mem_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_void_mem_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct get_function_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker7<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_invoker7<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_function_obj_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_obj_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_function_ref_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_ref_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_member_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker7<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_mem_invoker7<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker7 { };


      template<>
      struct get_invoker7<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_invoker7<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker7<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker7<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_member_invoker7<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker7<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker7<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_obj_invoker7<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker7<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker7<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_ref_invoker7<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker7<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
      struct basic_vtable7
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
  >
  class function7 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable7<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 7;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 7;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;

    typedef function7 self_type;

    function7() : function_base() { }



    template<typename Functor>
    function7(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function7(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function7(clear_type*) : function_base() { }







    function7(const function7& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function7() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function7&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function7& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function7& operator=(const function7& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function7& other)
    {
      if (&other == this)
        return;

      function7 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function7& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker7<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker7<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function7& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  inline void swap(function7<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6
                   >& f1,
                   function7<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  typename function7<
      R , T0 , T1 , T2 , T3 , T4 , T5 , T6>::result_type
  inline
  function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  void operator==(const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
                  const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  void operator!=(const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
                  const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
  : public function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
{
  typedef function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 49 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 83 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 8
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 52 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_8 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
        >
      struct function_invoker8
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
        >
      struct void_function_invoker8
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_obj_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct void_function_obj_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_ref_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct void_function_ref_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_mem_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_void_mem_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct get_function_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker8<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_invoker8<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_function_obj_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_obj_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_function_ref_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_ref_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_member_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker8<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_mem_invoker8<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker8 { };


      template<>
      struct get_invoker8<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_invoker8<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker8<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker8<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_member_invoker8<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker8<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker8<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_obj_invoker8<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker8<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker8<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_ref_invoker8<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker8<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
      struct basic_vtable8
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
  >
  class function8 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable8<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 8;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 8;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;

    typedef function8 self_type;

    function8() : function_base() { }



    template<typename Functor>
    function8(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function8(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function8(clear_type*) : function_base() { }







    function8(const function8& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function8() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function8&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function8& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function8& operator=(const function8& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function8& other)
    {
      if (&other == this)
        return;

      function8 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function8& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker8<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker8<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function8& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  inline void swap(function8<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                   >& f1,
                   function8<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  typename function8<
      R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>::result_type
  inline
  function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  void operator==(const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
                  const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  void operator!=(const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
                  const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
  : public function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
{
  typedef function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 54 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 88 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 9
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 57 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_9 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
        >
      struct function_invoker9
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
        >
      struct void_function_invoker9
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_obj_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct void_function_obj_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_ref_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct void_function_ref_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_mem_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_void_mem_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct get_function_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker9<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_invoker9<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_function_obj_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_obj_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_function_ref_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_ref_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_member_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker9<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_mem_invoker9<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker9 { };


      template<>
      struct get_invoker9<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_invoker9<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker9<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker9<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_member_invoker9<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker9<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker9<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_obj_invoker9<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker9<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker9<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_ref_invoker9<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker9<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
      struct basic_vtable9
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
  >
  class function9 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable9<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 9;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 9;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;

    typedef function9 self_type;

    function9() : function_base() { }



    template<typename Functor>
    function9(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function9(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function9(clear_type*) : function_base() { }







    function9(const function9& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function9() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function9&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function9& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function9& operator=(const function9& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function9& other)
    {
      if (&other == this)
        return;

      function9 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function9& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker9<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker9<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function9& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  inline void swap(function9<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                   >& f1,
                   function9<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  typename function9<
      R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>::result_type
  inline
  function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  void operator==(const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
                  const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  void operator!=(const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
                  const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
  : public function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
{
  typedef function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 59 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 93 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1


#define BOOST_PP_ITERATION_1 10
# 1 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 1
# 13 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp"
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
# 1 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 1
# 62 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp"
#define BOOST_FUNCTION_10 
# 1 "/usr/include/boost-1_41/boost/function/function_template.hpp" 1
# 21 "/usr/include/boost-1_41/boost/function/function_template.hpp"
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);


#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)





#define BOOST_FUNCTION_COMMA ,



#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)


#define BOOST_FUNCTION_VOID_RETURN_TYPE void
#define BOOST_FUNCTION_RETURN(X) X





namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
        >
      struct function_invoker10
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
        >
      struct void_function_invoker10
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_obj_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct void_function_obj_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_ref_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct void_function_ref_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_mem_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_void_mem_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct get_function_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker10<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_invoker10<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_function_obj_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_obj_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_function_ref_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_ref_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_member_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker10<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_mem_invoker10<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };
# 326 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename Tag>
      struct get_invoker10 { };


      template<>
      struct get_invoker10<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_invoker10<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker10<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker10<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_member_invoker10<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker10<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker10<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_obj_invoker10<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker10<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker10<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_ref_invoker10<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker10<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 475 "/usr/include/boost-1_41/boost/function/function_template.hpp"
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
      struct basic_vtable10
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9);

        template<typename F>
        bool assign_to(F f, function_buffer& functor)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a)
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor)
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
        {
          this->clear(functor);
          if (f) {


            functor.func_ptr = (void (*)())(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
        {



          if (f) {
            this->assign_to(mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
        {



          if (f) {
            this->assign_to_a(mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
        {
          new ((void*)&functor.data) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag)
        {
          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag)
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
  >
  class function10 : public function_base
# 664 "/usr/include/boost-1_41/boost/function/function_template.hpp"
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable10<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
    }

    struct clear_type {};

  public:
    static const int args = 10;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    static const int arity = 10;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;

    typedef function10 self_type;

    function10() : function_base() { }



    template<typename Functor>
    function10(Functor f

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function10(Functor f, Allocator a

                            ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function10(clear_type*) : function_base() { }







    function10(const function10& f) : function_base()
    {
      this->assign_to_own(f);
    }

    ~function10() { clear(); }
# 766 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const;







    template<typename Functor>

    typename enable_if_c<
               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               function10&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function10& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 824 "/usr/include/boost-1_41/boost/function/function_template.hpp"
    function10& operator=(const function10& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }

    void swap(function10& other)
    {
      if (&other == this)
        return;

      function10 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function10& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker10<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using detail::function::vtable_base;

      typedef typename detail::function::get_function_tag<Functor>::type tag;
      typedef detail::function::get_invoker10<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= (std::size_t)0x01;
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function10& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  inline void swap(function10<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                   >& f1,
                   function10<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                   >& f2)
  {
    f1.swap(f2);
  }


  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  typename function10<
      R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::result_type
  inline
  function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
  ::operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
  {
    if (this->empty())
      boost::throw_exception(bad_function_call());

    return get_vtable()->invoker
             (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
  }



template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  void operator==(const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
                  const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  void operator!=(const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
                  const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>& );






#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))


template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
  : public function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
{
  typedef function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};

#undef BOOST_FUNCTION_PARTIAL_SPEC


}


#undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_MEMBER_INVOKER
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
# 64 "/usr/include/boost-1_41/boost/function/detail/maybe_include.hpp" 2
# 15 "/usr/include/boost-1_41/boost/function/detail/function_iterate.hpp" 2
#undef BOOST_FUNCTION_NUM_ARGS
# 98 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
#undef BOOST_PP_ITERATION_1
# 1332 "/usr/include/boost-1_41/boost/preprocessor/iteration/detail/iter/forward1.hpp"
#undef BOOST_PP_IS_ITERATING

#undef BOOST_PP_ITERATION_DEPTH
#define BOOST_PP_ITERATION_DEPTH() 0

#undef BOOST_PP_ITERATION_START_1
#undef BOOST_PP_ITERATION_FINISH_1
#undef BOOST_PP_FILENAME_1

#undef BOOST_PP_ITERATION_FLAGS_1
#undef BOOST_PP_ITERATION_PARAMS_1
# 65 "/usr/include/boost-1_41/boost/function.hpp" 2
#undef BOOST_PP_ITERATION_PARAMS_1
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp" 2
# 1 "/usr/include/boost-1_41/boost/bind.hpp" 1

#define BOOST_BIND_HPP_INCLUDED 
# 22 "/usr/include/boost-1_41/boost/bind.hpp"
# 1 "/usr/include/boost-1_41/boost/bind/bind.hpp" 1

#define BOOST_BIND_BIND_HPP_INCLUDED 
# 27 "/usr/include/boost-1_41/boost/bind/bind.hpp"
# 1 "/usr/include/boost-1_41/boost/type.hpp" 1






#define BOOST_TYPE_DWA20010120_HPP 

namespace boost {



  template <class T>
  struct type {};

}
# 28 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/is_placeholder.hpp" 1

#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED 
# 21 "/usr/include/boost-1_41/boost/is_placeholder.hpp"
namespace boost
{

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

}
# 29 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/bind/arg.hpp" 1

#define BOOST_BIND_ARG_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/bind/arg.hpp"
namespace boost
{

template< int I > struct arg
{
    arg()
    {
    }

    template< class T > arg( T const & )
    {

        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
    }
};

template< int I > bool operator==( arg<I> const &, arg<I> const & )
{
    return true;
}



template< int I > struct is_placeholder< arg<I> >
{
    enum _vt { value = I };
};

template< int I > struct is_placeholder< arg<I> (*) () >
{
    enum _vt { value = I };
};



}
# 30 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2

# 1 "/usr/include/boost-1_41/boost/visit_each.hpp" 1
# 11 "/usr/include/boost-1_41/boost/visit_each.hpp"
#define BOOST_VISIT_EACH_HPP 



namespace boost {
  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t, long)
  {
    visitor(t);
  }

  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t)
  {
    visit_each(visitor, t, 0);
  }
}
# 32 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2






#define BOOST_BIND_VISIT_EACH visit_each


# 1 "/usr/include/boost-1_41/boost/bind/storage.hpp" 1

#define BOOST_BIND_STORAGE_HPP_INCLUDED 
# 32 "/usr/include/boost-1_41/boost/bind/storage.hpp"
namespace boost
{

namespace _bi
{



template<class A1> struct storage1
{
    explicit storage1( A1 a1 ): a1_( a1 ) {}

    template<class V> void accept(V & v) const
    {
        visit_each(v, a1_, 0);
    }

    A1 a1_;
};



template<int I> struct storage1< boost::arg<I> >
{
    explicit storage1( boost::arg<I> ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};

template<int I> struct storage1< boost::arg<I> (*) () >
{
    explicit storage1( boost::arg<I> (*) () ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};





template<class A1, class A2> struct storage2: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a2_, 0);
    }

    A2 a2_;
};



template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};

template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a3_, 0);
    }

    A3 a3_;
};



template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};

template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a4_, 0);
    }

    A4 a4_;
};



template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a5_, 0);
    }

    A5 a5_;
};



template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a6_, 0);
    }

    A6 a6_;
};



template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a7_, 0);
    }

    A7 a7_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a8_, 0);
    }

    A8 a8_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a9_, 0);
    }

    A9 a9_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};



}

}
# 42 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2






namespace boost
{

template<class T> class weak_ptr;

namespace _bi
{



template<class R, class F> struct result_traits
{
    typedef R type;
};



struct unspecified {};

template<class F> struct result_traits<unspecified, F>
{
    typedef typename F::result_type type;
};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
    typedef typename F::result_type type;
};





template<class T> bool ref_compare( T const & a, T const & b, long )
{
    return a == b;
}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
{
    return true;
}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
{
    return true;
}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
{
    return a.get_pointer() == b.get_pointer();
}



template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
{
    return a.compare( b );
}



template<class T> class value
{
public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }
    T const & get() const { return t_; }

    bool operator==(value const & rhs) const
    {
        return t_ == rhs.t_;
    }

private:

    T t_;
};



template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
{
    return !(a.get() < b.get()) && !(b.get() < a.get());
}



template<class T> class type {};



template<class F> struct unwrapper
{
    static inline F & unwrap( F & f, long )
    {
        return f;
    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
    {
        return rf.get();
    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
    {
        return _mfi::dm<R, T>( pm );
    }
};



class list0
{
public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
        return unwrapper<F>::unwrap(f, 0)();
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)
    {
        unwrapper<F>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
    {
        unwrapper<F const>::unwrap(f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

    bool operator==(list0 const &) const
    {
        return true;
    }
};

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

#define BOOST_BIND_RETURN return
# 1 "/usr/include/boost-1_41/boost/bind/bind_template.hpp" 1
# 15 "/usr/include/boost-1_41/boost/bind/bind_template.hpp"
    typedef typename result_traits<R, F>::type result_type;

    result_type operator()()
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A> result_type eval(A & a)
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
    {


        using boost::visit_each;


        visit_each(v, f_, 0);
        l_.accept(v);
    }

    bool compare(this_type const & rhs) const
    {
        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
    }

private:

    F f_;
    L l_;
# 863 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2
#undef BOOST_BIND_RETURN

};
# 929 "/usr/include/boost-1_41/boost/bind/bind.hpp"
template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
{
    return a.compare(b);
}
# 983 "/usr/include/boost-1_41/boost/bind/bind.hpp"
template< class T, int I > struct add_value_2
{
    typedef boost::arg<I> type;
};

template< class T > struct add_value_2< T, 0 >
{
    typedef _bi::value< T > type;
};

template<class T> struct add_value
{
    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
};



template<class T> struct add_value< value<T> >
{
    typedef _bi::value<T> type;
};

template<class T> struct add_value< reference_wrapper<T> >
{
    typedef reference_wrapper<T> type;
};

template<int I> struct add_value< arg<I> >
{
    typedef boost::arg<I> type;
};

template<int I> struct add_value< arg<I> (*) () >
{
    typedef boost::arg<I> (*type) ();
};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
{
    typedef bind_t<R, F, L> type;
};
# 1066 "/usr/include/boost-1_41/boost/bind/bind.hpp"
template<class A1> struct list_av_1
{
    typedef typename add_value<A1>::type B1;
    typedef list1<B1> type;
};

template<class A1, class A2> struct list_av_2
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef list2<B1, B2> type;
};

template<class A1, class A2, class A3> struct list_av_3
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef list3<B1, B2, B3> type;
};

template<class A1, class A2, class A3, class A4> struct list_av_4
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef list4<B1, B2, B3, B4> type;
};

template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef list5<B1, B2, B3, B4, B5> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef list6<B1, B2, B3, B4, B5, B6> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef typename add_value<A9>::type B9;
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
};



struct logical_not
{
    template<class V> bool operator()(V const & v) const { return !v; }
};

template<class R, class F, class L>
    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
    operator! (bind_t<R, F, L> const & f)
{
    typedef list1< bind_t<R, F, L> > list_type;
    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
}



#define BOOST_BIND_OPERATOR(op,name) struct name { template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } }; template<class R, class F, class L, class A2> bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator op (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, name, list_type> ( name(), list_type(f, a2) ); }
# 1189 "/usr/include/boost-1_41/boost/bind/bind.hpp"
struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }

struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }

struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }

struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }

#undef BOOST_BIND_OPERATOR
# 1229 "/usr/include/boost-1_41/boost/bind/bind.hpp"
template<class V, class T> void visit_each( V & v, value<T> const & t, int )
{
    using boost::visit_each;
    visit_each( v, t.get(), 0 );
}

template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
{
    t.accept( v );
}



}
# 1263 "/usr/include/boost-1_41/boost/bind/bind.hpp"
template< class T > struct is_bind_expression
{
    enum _vt { value = 0 };
};



template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
{
    enum _vt { value = 1 };
};






#define BOOST_BIND bind




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





#define BOOST_BIND_CC 
#define BOOST_BIND_ST 

# 1 "/usr/include/boost-1_41/boost/bind/bind_cc.hpp" 1
# 15 "/usr/include/boost-1_41/boost/bind/bind_cc.hpp"
template<class R>
    _bi::bind_t<R, R ( *) (), _bi::list0>
    bind( R ( *f) ())
{
    typedef R ( *F) ();
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1), A1 a1)
{
    typedef R ( *F) (B1);
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2), A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2);
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3);
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4);
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5);
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6);
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1539 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2

#undef BOOST_BIND_CC
#undef BOOST_BIND_ST
# 1581 "/usr/include/boost-1_41/boost/bind/bind.hpp"
#define BOOST_BIND_MF_NAME(X) X
#define BOOST_BIND_MF_CC 

# 1 "/usr/include/boost-1_41/boost/bind/bind_mf_cc.hpp" 1
# 17 "/usr/include/boost-1_41/boost/bind/bind_mf_cc.hpp"
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1585 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2
# 1 "/usr/include/boost-1_41/boost/bind/bind_mf2_cc.hpp" 1
# 18 "/usr/include/boost-1_41/boost/bind/bind_mf2_cc.hpp"
template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1586 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2

#undef BOOST_BIND_MF_NAME
#undef BOOST_BIND_MF_CC
# 1645 "/usr/include/boost-1_41/boost/bind/bind.hpp"
namespace _bi
{

template< class Pm, int I > struct add_cref;

template< class M, class T > struct add_cref< M T::*, 0 >
{
    typedef M type;
};

template< class M, class T > struct add_cref< M T::*, 1 >
{
    typedef M const & type;
};

template< class R, class T > struct add_cref< R (T::*) (), 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const, 1 >
{
    typedef void type;
};



template<class R> struct isref
{
    enum value_type { value = 0 };
};

template<class R> struct isref< R& >
{
    enum value_type { value = 1 };
};

template<class R> struct isref< R* >
{
    enum value_type { value = 1 };
};

template<class Pm, class A1> struct dm_result
{
    typedef typename add_cref< Pm, 1 >::type type;
};

template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
{
    typedef typename bind_t<R, F, L>::result_type result_type;
    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
};

}

template< class A1, class M, class T >

_bi::bind_t<
    typename _bi::dm_result< M T::*, A1 >::type,
    _mfi::dm<M, T>,
    typename _bi::list_av_1<A1>::type
>

bind( M T::*f, A1 a1 )
{
    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
    typedef _mfi::dm<M, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
}



}



# 1 "/usr/include/boost-1_41/boost/bind/placeholders.hpp" 1

#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED 
# 25 "/usr/include/boost-1_41/boost/bind/placeholders.hpp"
namespace
{
# 55 "/usr/include/boost-1_41/boost/bind/placeholders.hpp"
boost::arg<1> _1;
boost::arg<2> _2;
boost::arg<3> _3;
boost::arg<4> _4;
boost::arg<5> _5;
boost::arg<6> _6;
boost::arg<7> _7;
boost::arg<8> _8;
boost::arg<9> _9;



}
# 1725 "/usr/include/boost-1_41/boost/bind/bind.hpp" 2
# 23 "/usr/include/boost-1_41/boost/bind.hpp" 2
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp" 2




namespace rw { namespace common {







    class PropertyBase
    {
    public:






        PropertyBase(const std::string& identifier, const std::string& description);
# 62 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp"
        PropertyBase(const std::string& identifier,
                     const std::string& description,
                     const PropertyType& type);




        virtual ~PropertyBase();





        const std::string& getIdentifier() const;





        const std::string& getDescription() const;




        virtual PropertyBase* clone() const = 0;




        typedef boost::function<void(PropertyBase*)> PropertyChangedListener;





        void addChangedListener(PropertyChangedListener callback);





        const PropertyType& getType() const;

    protected:



        void notifyListeners();

    private:



        std::string _identifier;




        std::string _description;




        PropertyType _propertyType;




        std::vector<PropertyChangedListener> _listeners;

    private:
        PropertyBase(const PropertyBase&);
        PropertyBase& operator=(const PropertyBase&);
    };



    typedef rw::common::Ptr<PropertyBase> PropertyBasePtr;

}}
# 28 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
#define RW_COMMON_PROPERTYMAP_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyBase.hpp" 1
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp"
#define RW_COMMON_PROPERTY_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp"
namespace rw { namespace common {
# 40 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp"
    template<class T>
    class Property: public PropertyBase
    {
    public:
# 53 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp"
        Property(
            const std::string& identifier,
            const std::string& description,
            T value)
            :
            PropertyBase(identifier, description, PropertyType::getType(value)),
            _value(value)
        {}
# 69 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/Property.hpp"
        Property(
            const std::string& identifier,
            const std::string& description,
            const PropertyType& type,
            T value)
            :
            PropertyBase(identifier, description, type),
            _value(value)
        {}





        virtual ~Property() {};





        T& getValue() {
            return _value;
        }





        const T& getValue() const {
            return _value;
        }





        void setValue(const T& value) {
            _value = value;
        }




        Property<T>* clone() const
        {
            return new Property<T>(this->getIdentifier(),
                                   this->getDescription(),
                                   this->getType(),
                                   this->_value);
        }

    private:
        T _value;
    };


}}
# 28 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
#define RW_COMMON_STRINGUTIL_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
namespace rw { namespace common {







    class StringUtil
    {
    public:



        static bool isAbsoluteFileName(const std::string& file);





        static std::string replaceBackslash(const std::string& file);
# 63 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
        static std::string getDirectoryName(const std::string& path);
# 78 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
        static std::string getFileExtension(const std::string& filename);
# 88 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
        static std::string toUpper(const std::string& str);
# 98 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/StringUtil.hpp"
        static std::string toLower(const std::string& str);







        static std::string quote(const std::string& str);





        static std::vector<std::string> words(const std::string& str);





        static std::pair<bool, double> toDouble(const std::string& str);





        static std::pair<bool, int> toInt(const std::string& str);





        static std::pair<bool, std::vector<double> > toDoubles(
            const std::vector<std::string>& words);





        static std::pair<bool, std::vector<int> > toInts(const std::vector<std::string>& words);


    };



}}
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/macros.hpp" 1
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 2

# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/set" 1 3
# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/set" 3
#define _GLIBCXX_SET 1

       
# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/set" 3


# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
#define _STL_SET_H 1




namespace std __attribute__ ((__visibility__ ("default"))) {
# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
  template<typename _Key, typename _Compare = std::less<_Key>,
    typename _Alloc = std::allocator<_Key> >
    class set
    {

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:



      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;


    private:
      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;
      _Rep_type _M_t;

    public:


      typedef typename _Key_alloc_type::pointer pointer;
      typedef typename _Key_alloc_type::const_pointer const_pointer;
      typedef typename _Key_alloc_type::reference reference;
      typedef typename _Key_alloc_type::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;






      set()
      : _M_t() { }






      explicit
      set(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      template<typename _InputIterator>
        set(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_unique(__first, __last); }
# 174 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      template<typename _InputIterator>
        set(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t._M_insert_unique(__first, __last); }
# 188 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      set(const set& __x)
      : _M_t(__x._M_t) { }
# 226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      set&
      operator=(const set& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const
      { return _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(); }
# 360 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 385 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      void



      swap(set& __x)

      { _M_t.swap(__x._M_t); }
# 407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t._M_insert_unique(__x);
 return std::pair<iterator, bool>(__p.first, __p.second);
      }
# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_unique_(__position, __x); }
# 447 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_unique(__first, __last); }
# 474 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 489 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 504 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }







      void
      clear()
      { _M_t.clear(); }
# 528 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 546 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 567 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 583 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 608 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _K1, typename _C1, typename _A1>
        friend bool
        operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);

      template<typename _K1, typename _C1, typename _A1>
        friend bool
        operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
    };
# 637 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator==(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 654 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 706 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_set.h" 3
}
# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/set" 2 3
# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 1 3
# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
#define _STL_MULTISET_H 1




namespace std __attribute__ ((__visibility__ ("default"))) {
# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
  template <typename _Key, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<_Key> >
    class multiset
    {

      typedef typename _Alloc::value_type _Alloc_value_type;
     
     

     

    public:

      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;

      _Rep_type _M_t;

    public:
      typedef typename _Key_alloc_type::pointer pointer;
      typedef typename _Key_alloc_type::const_pointer const_pointer;
      typedef typename _Key_alloc_type::reference reference;
      typedef typename _Key_alloc_type::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;





      multiset()
      : _M_t() { }






      explicit
      multiset(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_equal(__first, __last); }
# 167 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t._M_insert_equal(__first, __last); }
# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      multiset(const multiset& __x)
      : _M_t(__x._M_t) { }
# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const
      { return _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(); }
# 353 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      void



      swap(multiset& __x)

      { _M_t.swap(__x._M_t); }
# 398 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 422 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t._M_insert_equal_(__position, __x); }
# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_equal(__first, __last); }
# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 477 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }







      void
      clear()
      { _M_t.clear(); }
# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 552 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 568 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/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); }
# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }

      template<typename _K1, typename _C1, typename _A1>
        friend bool
        operator==(const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);

      template<typename _K1, typename _C1, typename _A1>
        friend bool
        operator< (const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);
    };
# 623 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 640 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
       const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
       const multiset<_Key,_Compare,_Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(multiset<_Key, _Compare, _Alloc>& __x,
  multiset<_Key, _Compare, _Alloc>& __y)
    { __x.swap(__y); }
# 695 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/bits/stl_multiset.h" 3
}
# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4/set" 2 3
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp" 2


namespace rw { namespace common {
# 55 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
    class PropertyMap {
    public:



        PropertyMap();




        ~PropertyMap();




        PropertyMap(const PropertyMap& other);




        PropertyMap& operator=(const PropertyMap& other);




        void swap(PropertyMap& other);
# 91 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        void set(const std::string& identifier, const T& value)
        {
            Property<T>* prop = findProperty<T>(identifier);
            if (prop)
                prop->setValue(value);
            else
                add(identifier, "", value);
        }
# 113 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template <typename T>
        rw::common::Ptr<Property<T> > add(const std::string& identifier,
                         const std::string& description,
                         const T& value)
        {
            rw::common::Ptr<Property<T> > property(new Property<T>(identifier, description, value));

            const bool ok = insert(property);
            if (ok)
                return property;
            else
                return __null;
        }
# 135 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        bool add(PropertyBasePtr property);
# 147 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        T* getPtr(const std::string& identifier)
        {
            Property<T>* prop = findProperty<T>(identifier);
            if (prop)
                return &prop->getValue();
            else
                return __null;
        }
# 167 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        const T* getPtr(const std::string& identifier) const
        {

            return const_cast<PropertyMap*>(this)->getPtr<T>(identifier);
        }
# 184 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        T& get(const std::string& identifier)
        {
            T* p = getPtr<T>(identifier);
            if (!p) {
                do { int RW__line = 192; std::stringstream RW__stream; RW__stream << "Property " << StringUtil::quote(identifier) << " could not be found"; rw::common::Message RW__message("/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp", RW__line, RW__stream.str()); rw::common::Log::errorLog().write(RW__message); throw rw::common::Exception(RW__message); } while (0);



            }
            return *p;
        }
# 207 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        const T& get(const std::string& identifier) const
        {

            return const_cast<PropertyMap*>(this)->get<T>(identifier);
        }
# 229 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        T& get(const std::string& identifier, T& defval)
        {
            T* p = getPtr<T>(identifier);
            if (!p) {
             return defval;
            }
            return *p;
        }
# 254 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        const T& get(const std::string& identifier, const T& defval) const
        {
            const T* p = getPtr<T>(identifier);
            if (!p) {
                return defval;
            }
            return *p;
        }
# 271 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        bool has(const std::string& identifier) const;




        size_t size() const;




        bool empty() const;






        bool erase(const std::string& identifier);
# 304 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        Property<T>* findProperty(const std::string& identifier)
        {
            return dynamic_cast<Property<T>*>(findPropertyBase(identifier));
        }
# 321 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        template<class T>
        const Property<T>* findProperty(const std::string& identifier) const
        {
            return dynamic_cast<const Property<T>*>(
                findPropertyBase(identifier));
        }
# 336 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        PropertyBase* findPropertyBase(const std::string& identifier);
# 346 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        const PropertyBase* findPropertyBase(const std::string& identifier) const;

    private:
        struct CmpPropertyBase
        {
            bool operator()(
                const PropertyBasePtr a,
                const PropertyBasePtr b) const
            {
                return a->getIdentifier() < b->getIdentifier();
            }
        };

        typedef std::set<PropertyBasePtr, CmpPropertyBase> MapType;

    public:

        typedef MapType::const_iterator iterator;
# 372 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/PropertyMap.hpp"
        std::pair<iterator, iterator> getProperties() const;


    private:
        bool insert(PropertyBasePtr property);

    private:
        MapType _properties;
    };


}}
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/ConcatVectorIterator.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/ConcatVectorIterator.hpp"
#define RW_COMMON_CONCATVECTORITERATOR_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/ConcatVectorIterator.hpp"
namespace rw { namespace common {




    template <typename T>
    class ConstConcatVectorIterator;





    template <typename T>
    class ConcatVectorIterator
    {
        typedef std::vector<T*> PtrTVector;
        typedef typename PtrTVector::const_iterator I;

        const PtrTVector* curr;
        I pos;
        const PtrTVector* next;

        friend class ConstConcatVectorIterator<T>;

    public:

        typedef std::forward_iterator_tag iterator_category;


        typedef T value_type;


        typedef T* pointer;


        typedef T& reference;


        typedef ptrdiff_t difference_type;
# 86 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/common/ConcatVectorIterator.hpp"
        ConcatVectorIterator(const PtrTVector* curr, I pos, const PtrTVector* next) :
   curr(curr),
   pos(pos),
   next(next)
        {
            skipIfEndOfCurr();
        }




        T& operator*() const { return **pos; }




        T* operator->() const { return *pos.operator->(); }





        ConcatVectorIterator& operator++()
        {
            inc();
            return *this;
        }





        ConcatVectorIterator operator++(int)
        {
            ConcatVectorIterator before = *this;
            inc();
            return before;
        }






        bool operator==(const ConcatVectorIterator& other) const
        {
            return
                curr == other.curr &&
                pos == other.pos &&
                next == other.next;
        }






        bool operator!=(const ConcatVectorIterator& other) const
        {




   return this->curr != other.curr || this->pos != other.pos;
  }

    private:
        void inc()
        {
            ++pos;
            skipIfEndOfCurr();
        }

        void skipIfEndOfCurr()
        {
            if (next && pos == curr->end()) {
                pos = next->begin();
                curr = next;
                next = 0;
            }
        }
    };





    template <typename T>
    class ConstConcatVectorIterator
    {
    public:

        typedef std::forward_iterator_tag iterator_category;


        typedef T const value_type;


        typedef T const* pointer;


        typedef T const& reference;


        typedef ptrdiff_t difference_type;







        ConstConcatVectorIterator(ConcatVectorIterator<T> pos) :
            pos(pos)
        {}




        const T& operator*() const { return *pos; }




        const T* operator->() const { return pos.operator->(); }





        ConstConcatVectorIterator& operator++() { ++pos; return *this; }





        ConstConcatVectorIterator operator++(int)
        { return ConstConcatVectorIterator(pos++); }






        bool operator==(const ConstConcatVectorIterator& other) const
        { return pos == other.pos; }






        bool operator!=(const ConstConcatVectorIterator& other) const
        {
   return pos != other.pos;
  }

    private:

        ConcatVectorIterator<T> pos;
    };


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 2


# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
#define RW_KINEMATICS_STATEDATA_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/State.hpp" 1
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp" 2

namespace rw { namespace kinematics {
# 44 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
    class StateData {

    public:



        virtual ~StateData(){ };
# 65 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
        inline int getID() const { return _id; }






        const std::string& getName() const { return _name; }







        inline int size() const { return _size; };
# 93 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
        inline const double* getQ(const State& state) const {
            if( _size==0 ) return __null;
            return state.getQState().getQ(*this);
        }
# 116 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
        inline void setQ(State& state, const double* vals) const{
            if( _size==0 ) return;
            state.getQState().setQ(*this, vals);
        }

    protected:
# 138 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateData.hpp"
        StateData(int size, const std::string& name);

    private:






        friend class StateStructure;

        void setID(int id) { _id = id; }

    private:




        int _id;



        const int _size;


        std::string _name;

    private:

        StateData(const StateData&);
        StateData& operator=(const StateData&);

    };

}}
# 33 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 2

namespace rw { namespace kinematics {




    class State;
# 55 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
    class Frame : public StateData
    {
        typedef std::vector<Frame*> ChildList;

    public:




        virtual ~Frame() { }
# 79 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        void multiplyTransform(const math::Transform3D<>& parent,
                               const State& state,
                               math::Transform3D<>& result) const {
            doMultiplyTransform(parent, state, result);
        }
# 97 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        math::Transform3D<> getTransform(const State& state) const {
            return doGetTransform(state);
        }
# 116 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        const common::PropertyMap& getPropertyMap() const { return _propertyMap; }




        common::PropertyMap& getPropertyMap() { return _propertyMap; }
# 136 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        int getDOF() const { return size(); }







        const Frame* getParent() const { return _parent; }




        Frame* getParent() { return _parent; }
# 160 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        Frame* getParent(const State& state);




        const Frame* getParent(const State& state) const;





        const Frame* getDafParent(const State& state) const;




        Frame* getDafParent(const State& state);






        typedef common::ConcatVectorIterator<Frame> iterator;




        typedef common::ConstConcatVectorIterator<Frame> const_iterator;




        typedef std::pair<iterator, iterator> iterator_pair;




        typedef std::pair<const_iterator, const_iterator> const_iterator_pair;




        const_iterator_pair getChildren() const
        { return makeConstIteratorPair(_children); }




        iterator_pair getChildren()
        { return makeIteratorPair(_children); }




        const_iterator_pair getChildren(const State& state) const;




        iterator_pair getChildren(const State& state);





        const_iterator_pair getDafChildren(const State& state) const;




        iterator_pair getDafChildren(const State& state);
# 247 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        void attachTo(Frame* parent, State& state);

    protected:
# 264 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp"
        Frame(int dof, const std::string& name);

    protected:



        virtual void doMultiplyTransform(const math::Transform3D<>& parent,
                                         const State& state,
                                         math::Transform3D<>& result) const = 0;




        virtual math::Transform3D<> doGetTransform(const State& state) const = 0;

    private:
        friend class StateStructure;

        void setParent(Frame *frame){

            _parent = frame;
        }

        void removeChild(Frame *frame){
            for (ChildList::iterator it = _children.begin(); it != _children.end(); ++it)
                if ((*it) == frame) {
                    _children.erase(it);
                    return;
                }
        }

    private:


        common::PropertyMap _propertyMap;


        Frame* _parent;
        ChildList _children;

        void addChild(Frame* child) {

            _children.push_back(child);
        }

        static iterator_pair makeIteratorPair(const ChildList& children)
        {
            return std::make_pair(
                iterator(&children, children.begin(), __null),
                iterator(&children, children.end(), __null));
        }

        static const_iterator_pair makeConstIteratorPair(
            const ChildList& children)
        {
            return std::make_pair(
                const_iterator(iterator(&children, children.begin(), __null)),
                const_iterator(iterator(&children, children.end(), __null)));
        }

        static iterator_pair makeIteratorPair(
            const ChildList& first,
            const ChildList& next)
        {
            return std::make_pair(
                iterator(&first, first.begin(), &next),
                iterator(&next, next.end(), __null));
        }

        static const_iterator_pair makeConstIteratorPair(
            const ChildList& first,
            const ChildList& next)
        {
   if (first.size() == 0)
    return std::make_pair(
     const_iterator(iterator(&next, next.begin(), &next)),
     const_iterator(iterator(&next, next.end(), __null)));
   else
    return std::make_pair(
     const_iterator(iterator(&first, first.begin(), &next)),
     const_iterator(iterator(&next, next.end(), __null)));
        }

    private:

        Frame(const Frame&);
        Frame& operator=(const Frame&);
    };




    typedef std::pair<Frame*, Frame*> FramePair;




    typedef std::pair<const Frame*, const Frame*> ConstFramePair;




 typedef std::set<kinematics::Frame*> FrameSet;




 typedef std::set<kinematics::FramePair> FramePairSet;




 typedef std::vector<kinematics::FramePair> FramePairList;




    std::ostream& operator<<(std::ostream& out, const Frame& frame);


}}
# 23 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp"
#define RW_MODELS_SERIALDEVICE_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp"
#define RW_MODELS_JOINTDEVICE_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
#define RW_MODELS_DEVICE_HPP 
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JacobianCalculator.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JacobianCalculator.hpp"
#define RW_MODELS_JACOBIANCALCULATOR_HPP 


# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
#define RW_MATH_JACOBIAN_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Q.hpp" 1
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp" 2







namespace rw { namespace math {
# 52 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
    class Jacobian
    {
    public:

        typedef boost::numeric::ublas::matrix<double> Base;


        typedef boost::numeric::ublas::zero_matrix<double> ZeroBase;


        typedef boost::numeric::ublas::zero_matrix<double> IdentityBase;
# 71 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
        Jacobian(size_t m, size_t n) : _jac(m, n) {}




        size_t size1() const { return m().size1(); }




        size_t size2() const { return m().size2(); }






        explicit Jacobian(size_t n) : _jac(6, n) {}






        template <class R>
        explicit
        Jacobian(const boost::numeric::ublas::matrix_expression<R>& r) :
            _jac(r)
        {}




        const Base& m() const { return _jac; }




        Base& m() { return _jac; }







        double& operator()(size_t row, size_t column)
        { return m()(row, column); }







        const double& operator()(size_t row, size_t column) const
        { return m()(row, column); }
# 153 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
        explicit Jacobian(const Transform3D<>& aTb);
# 179 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
        explicit Jacobian(const Rotation3D<>& aRb);
# 205 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
        explicit Jacobian(const Vector3D<>& aPb);


        void addRotation(const Vector3D<>& part, size_t row, size_t col);
        void addPosition(const Vector3D<>& part, size_t row, size_t col);

    private:
        Base _jac;
    };
# 222 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
    inline const VelocityScrew6D<> operator*(const Jacobian& Jq, const Q& dq)
    {
        return VelocityScrew6D<>(prod(Jq.m(), dq.m()));
    }
# 239 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
    inline const Q operator*(const Jacobian& JqInv, const VelocityScrew6D<>& v)
    {
        return Q(prod(JqInv.m(), v.m()));
    }
# 256 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
    inline const Jacobian operator*(const Jacobian& j1, const Jacobian& j2)
    {
        return Jacobian(prod(j1.m(), j2.m()));
    }






    inline std::ostream& operator<<(std::ostream& out, const Jacobian& v)
    {
        return out << v.m();
    }
# 278 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/math/Jacobian.hpp"
    const Jacobian operator*(const Rotation3D<>& r, const Jacobian& v);


}}
# 24 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JacobianCalculator.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
#define RW_KINEMATICS_FKTABLE_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FrameMap.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FrameMap.hpp"
#define RW_KINEMATICS_FRAMEMAP_HPP 





namespace rw { namespace kinematics {







    template <class T>
    class FrameMap {
    public:




        FrameMap(int s = 20) :
            _initialSize(s),
            _defaultVal(false, T()),
            _map(_initialSize, _defaultVal)
        {}






        FrameMap(const T& defaultVal, int s = 20) :
            _initialSize(s),
            _defaultVal(false, defaultVal),
            _map(_initialSize, _defaultVal)
        {}






        void insert(const rw::kinematics::Frame& frame, const T& value)
        {
            operator[](frame) = value;
        }





        bool has(const rw::kinematics::Frame& frame)
        {
            const int idx = frame.getID();
            resizeIfNeeded(idx);
            return _map[idx].first;
        }
# 90 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FrameMap.hpp"
        const T& operator[](const rw::kinematics::Frame& frame) const
        {
            const int idx = frame.getID();
            resizeIfNeeded(idx);
            return _map[idx].second;
        }
# 107 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FrameMap.hpp"
        T& operator[](const rw::kinematics::Frame& frame)
        {
            const int idx = frame.getID();
            resizeIfNeeded(idx);
            OkVal& val = _map[idx];
            val.first = true;
            return val.second;
        }




        void erase( const rw::kinematics::Frame& frame ){
         const int idx = frame.getID();
         _map[idx].first = false;
        }




        void clear()
        {
            _map.clear();
            _map.resize(_initialSize, _defaultVal);
        }

    private:
        void resizeIfNeeded(int idx) const
        {
            const int n = (int)_map.size();
            if (idx >= n) {
                const int newSize = idx >= 2 * n ? idx + 1 : 2 * n;
                _map.resize(newSize, _defaultVal);
            }
        }

    private:
        typedef std::pair<bool, T> OkVal;

        int _initialSize;
        OkVal _defaultVal;
        mutable std::vector<OkVal> _map;
    };
}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp" 2
# 39 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
namespace rw { namespace kinematics {

    class Frame;
# 52 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
    class FKTable
    {
    public:






        FKTable(const State& state);







        FKTable(const State* state);
# 78 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
        const math::Transform3D<>& get(const Frame& frame) const;
# 87 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
        const State& getState() const { return *_sp; }
    private:
        const State* _sp;
        State _state;
# 117 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FKTable.hpp"
        typedef FrameMap<math::Transform3D<> > TransformMap;




        mutable TransformMap _transforms;





    private:
        FKTable(const FKTable&);
        FKTable& operator=(const FKTable&);
    };


}}
# 26 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JacobianCalculator.hpp" 2

namespace rw {
namespace models {






class JacobianCalculator
{
public:



    virtual ~JacobianCalculator();






    virtual rw::math::Jacobian get(const rw::kinematics::State& state) const {
        rw::kinematics::FKTable fk(state);
        return get(fk);
    }






    virtual rw::math::Jacobian get(const rw::kinematics::FKTable& fk) const = 0;


};


typedef rw::common::Ptr<JacobianCalculator> JacobianCalculatorPtr;


}
}
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp" 2





namespace rw { namespace math { class Jacobian; }}

namespace rw { namespace kinematics {
    class Frame;
    class State;
}}

namespace rw { namespace models {

    class Joint;




    class Device;


    typedef rw::common::Ptr<Device> DevicePtr;






    class Device
    {
    public:

        typedef std::pair<math::Q, math::Q> QBox;






        Device(const std::string& name) :
            _name(name)
        {}




        virtual ~Device(){}
# 88 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual void setQ(const math::Q& q, kinematics::State& state) const = 0;







        virtual math::Q getQ(const kinematics::State& state) const = 0;







        virtual QBox getBounds() const = 0;
# 113 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual void setBounds(const QBox& bounds) = 0;
# 124 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual math::Q getVelocityLimits() const = 0;
# 135 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual void setVelocityLimits(const math::Q& vellimits) = 0;
# 146 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual math::Q getAccelerationLimits() const = 0;
# 157 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual void setAccelerationLimits(const math::Q& acclimits) = 0;





        virtual size_t getDOF() const = 0;





        std::string getName() const { return _name; }





        void setName(const std::string& name) { _name = name; }






        virtual kinematics::Frame* getBase() = 0;






        virtual const kinematics::Frame* getBase() const = 0;






        virtual kinematics::Frame* getEnd() = 0;






        virtual const kinematics::Frame* getEnd() const = 0;







        math::Transform3D<double> baseTframe(
            const kinematics::Frame* f, const kinematics::State& state) const;







        math::Transform3D<double> baseTend(const kinematics::State& state) const;







        math::Transform3D<double> worldTbase(const kinematics::State& state) const;
# 296 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual math::Jacobian baseJend(const kinematics::State& state) const = 0;
# 328 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/Device.hpp"
        virtual math::Jacobian baseJframe(
            const kinematics::Frame* frame,
            const kinematics::State& state) const;







        virtual math::Jacobian baseJframes(const std::vector<kinematics::Frame*>& frames,
                                           const kinematics::State& state) const
        {
            return baseJCframes(frames, state)->get(state);
        }






        virtual JacobianCalculatorPtr baseJCend(const kinematics::State& state) const;






        virtual JacobianCalculatorPtr baseJCframe(const kinematics::Frame* frame, const kinematics::State& state) const;




        virtual JacobianCalculatorPtr baseJCframes(const std::vector<kinematics::Frame*>& frames, const kinematics::State& state) const = 0;

    private:
        std::string _name;

    private:
        Device(const Device&);
        Device& operator=(const Device&);
    };




    std::ostream& operator<<(std::ostream& out, const Device& device);


}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp" 2




namespace rw { namespace models {

    class Joint;
# 53 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp"
    class JointDevice: public Device
    {
    public:
# 70 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp"
        JointDevice(const std::string& name, kinematics::Frame* base,
                    kinematics::Frame* end,
                    const std::vector<Joint*>& joints,
                    const kinematics::State& state);
# 86 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp"
        const std::vector<Joint*>& getJoints() const {
            return _joints;
        }



        void setQ(const math::Q& q, kinematics::State& state) const;


        math::Q getQ(const kinematics::State& state) const;


        size_t getDOF() const;


        std::pair<math::Q, math::Q> getBounds() const;


        void setBounds(const std::pair<math::Q, math::Q>& bounds);


        math::Q getVelocityLimits() const;


        void setVelocityLimits(const math::Q& vellimits);


        math::Q getAccelerationLimits() const;


        void setAccelerationLimits(const math::Q& acclimits);


        math::Jacobian baseJend(const kinematics::State& state) const;







        JacobianCalculatorPtr baseJCframes(const std::vector<kinematics::Frame*>& frames,
                                           const kinematics::State& state) const;


        kinematics::Frame* getBase()
        {
            return _base;
        }


        const kinematics::Frame* getBase() const
        {
            return _base;
        }


        virtual kinematics::Frame* getEnd()
        {
            return _end;
        }


        virtual const kinematics::Frame* getEnd() const
        {
            return _end;
        }

    private:
# 164 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/JointDevice.hpp"
        kinematics::Frame* _base;
        kinematics::Frame* _end;

        std::vector<Joint*> _joints;
        size_t _dof;

        JacobianCalculatorPtr _baseJCend;


    };


    typedef rw::common::Ptr<JointDevice> JointDevicePtr;


}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp" 2




namespace rw { namespace models {

    class Joint;
# 45 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp"
    class SerialDevice : public JointDevice
    {
    public:
# 56 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp"
        SerialDevice(
            kinematics::Frame* first,
            kinematics::Frame* last,
            const std::string& name,
            const kinematics::State& state);
# 69 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp"
        const std::vector<kinematics::Frame*>& frames() const;
# 83 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/SerialDevice.hpp"
        SerialDevice(const std::vector<kinematics::Frame*>& serialChain,
                     const std::string& name,
                     const kinematics::State& state);


    private:
        std::vector<kinematics::Frame*> _kinematicChain;
    };




    typedef rw::common::Ptr<SerialDevice> SerialDevicePtr;


}}
# 24 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
#define RW_MODELS_WORKCELL_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
#define RW_KINEMATICS_STATESTRUCTURE_HPP 





# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Frame.hpp" 1
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp" 2






namespace rw { namespace kinematics {
    class StateSetup;
# 43 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
    class StateStructure {
    public:





        StateStructure();




        virtual ~StateStructure();
# 65 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        bool has(StateData *data);
# 74 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        int getMaxID() const { return _allDatas.size(); }
# 84 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        void addData(StateData *data);
# 94 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        void addFrame(Frame *frame, Frame *parent);
# 103 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        void addDAF(Frame *frame, Frame *parent);
# 118 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        void remove(StateData *data);







        State upgradeState(const State& oldState);





        State getDefaultState();






        void setDefaultState(const State &state);





        const std::vector<boost::shared_ptr<StateData> >& getStateData() const{
            return _allDatas;
        }







        const std::vector<Frame*>& getFrames() const{
            return _frames;
        }






        const std::vector<Frame*>& getDAFs() const{
            return _DAFs;
        }





        const Frame* getRoot() const {return _root;}





        Frame* getRoot(){return _root;}




        void cleanup();
# 195 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/StateStructure.hpp"
        kinematics::Frame* findFrame(const std::string& name) const;

    private:

        void updateDefaultState();

        int allocateDataID();

        void addDataInternal(StateData *data);

    private:

        int _version;


        Frame *_root;


        State _defaultState;



        std::vector<int> _initialDafParents;



        typedef std::vector<boost::shared_ptr<StateSetup> > StateSetupList;
        StateSetupList _setups;


        std::vector<Frame*> _frames;


        std::vector<Frame*> _DAFs;


        std::vector<boost::shared_ptr<StateData> > _allDatas;
        std::vector<boost::shared_ptr<StateData> > _currDatas;


        std::vector<int> _availableDataIds;


        typedef std::map<std::string, int> FrameIdxMap;
        FrameIdxMap _frameIdxMap;
    };

    typedef rw::common::Ptr<StateStructure> StateStructurePtr;


}}
# 27 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp" 2







namespace rw { namespace models {

    class Device;
    class DynamicObject;




    class WorkCell;


    typedef rw::common::Ptr<WorkCell> WorkCellPtr;
# 64 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
    class WorkCell {
    public:
# 78 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        WorkCell(
            kinematics::StateStructure* tree,
            const std::string& name = "");
# 90 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        ~WorkCell();





        std::string getName() const { return _name; }






        kinematics::Frame* getWorldFrame() const;
# 112 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        void addDevice(Device* device);







        const std::vector<Device*>& getDevices() const;
# 132 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        kinematics::Frame* findFrame(const std::string& name) const;
# 145 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        template<class T>
        T* findFrame(const std::string& name) const{
         rw::kinematics::Frame *frame = findFrame(name);
         if(frame==__null) return __null;
         return dynamic_cast<T*>(frame);
        }
# 161 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        Device* findDevice(const std::string& name) const;
# 171 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/models/WorkCell.hpp"
        template<class T>
        T* findDevice(const std::string& name) const{
         rw::models::Device *dev = findDevice(name);
         if(dev==__null) return __null;
         return dynamic_cast<T*>(dev);
        }






        kinematics::State getDefaultState() const;





        rw::common::Ptr<rw::kinematics::StateStructure> getStateStructure(){
            return _tree;
        }

    private:
        boost::shared_ptr<rw::kinematics::StateStructure> _tree;
        std::vector<Device*> _devices;
        std::string _name;

    private:
        WorkCell(const WorkCell&);
        WorkCell& operator=(const WorkCell&);
    };




    std::ostream& operator<<(std::ostream& out, const WorkCell& workcell);


}}
# 25 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp"
#define RW_PROXIMITY_DISTANCESTRATEGY_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
#define RW_PROXIMITY_PROXIMITYSTRATEGY_HPP 
# 31 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/Geometry.hpp" 1
# 19 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/Geometry.hpp"
#define RW_GEOMETRY_GEOMETRY_HPP_ 




# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/GeometryData.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/GeometryData.hpp"
#define RW_GEOMETRY_GEOMETRYDATA_HPP_ 






namespace rw { namespace geometry {


 class TriMesh;




 class GeometryData {

 public:
  typedef enum {PlainTriMesh,
       IdxTriMesh,
       SpherePrim, BoxPrim, OBBPrim, AABBPrim,
       LinePrim, PointPrim, PyramidPrim, ConePrim,
       TrianglePrim, CylinderPrim, PlanePrim, RayPrim,
       UserType} GeometryType;




  virtual GeometryType getType() const = 0;
# 61 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/GeometryData.hpp"
  virtual rw::common::Ptr<TriMesh> getTriMesh(bool forceCopy=true) = 0;





  static std::string toString(GeometryType type);
 };

 typedef rw::common::Ptr<GeometryData> GeometryDataPtr;


}
}
# 25 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/Geometry.hpp" 2

namespace rw { namespace geometry {
# 37 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/geometry/Geometry.hpp"
 class Geometry {
 public:






  Geometry(GeometryDataPtr data, double scale=1.0);







  Geometry(GeometryDataPtr data,
     const rw::math::Transform3D<>& t3d,
     double scale=1.0);


  virtual ~Geometry();


  double getScale() const {return _scale;}






  void setScale(double scale){_scale = scale;}


  void setTransform(const rw::math::Transform3D<>& t3d){_transform = t3d;};


  const rw::math::Transform3D<>& getTransform() const {return _transform;};


  GeometryDataPtr getGeometryData(){return _data;};


  const GeometryDataPtr getGeometryData() const {return _data;};


  void setGeometryData(GeometryDataPtr data){_data = data;};


  const std::string& getId() const {return _id; };


  void setId(const std::string& id) {_id = id; };





 private:

  GeometryDataPtr _data;

  rw::math::Transform3D<> _transform;
  double _scale;
  std::string _id;

 };

 typedef rw::common::Ptr<Geometry> GeometryPtr;

}
}
# 32 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp" 2
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/FrameMap.hpp" 1
# 33 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp" 2

# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityModel.hpp" 1
# 19 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityModel.hpp"
#define PROXIMITYMODEL_HPP_ 




namespace rw {
namespace proximity {

    class ProximityStrategy;

    class ProximityModel {
    public:
        ProximityModel(ProximityStrategy *owner_tmp):
            owner(owner_tmp)
        {}

        virtual ~ProximityModel();

        std::vector<std::string> getGeometryIDs();
# 46 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityModel.hpp"
        bool addGeometry(const rw::geometry::Geometry& geom);
        bool removeGeometry(const std::string& geoid);

        ProximityStrategy *owner;
    private:

    };

    typedef rw::common::Ptr<ProximityModel> ProximityModelPtr;

}
}
# 35 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp" 2

namespace rw { namespace proximity {
# 46 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
    class ProximityStrategy {
    public:



        virtual ~ProximityStrategy();
# 64 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
        virtual bool addModel(const kinematics::Frame* frame);
# 76 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
        virtual bool addModel(
            const rw::kinematics::Frame* frame,
            const rw::geometry::Geometry& faces

            );
# 91 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/ProximityStrategy.hpp"
        virtual bool hasModel(const rw::kinematics::Frame* frame);




        virtual void clearFrame(const rw::kinematics::Frame* frame);




        virtual void clearFrames();


        ProximityModelPtr getModel(const rw::kinematics::Frame* frame);


        virtual ProximityModelPtr createModel() = 0;

        virtual void destroyModel(ProximityModel* model) = 0;




        virtual bool addGeometry(ProximityModel* model,
          const rw::geometry::Geometry& geom) = 0;




        virtual bool removeGeometry(ProximityModel* model, const std::string& geomId) = 0;







        virtual std::vector<std::string> getGeometryIDs(ProximityModel* model) = 0;




        virtual void clear() = 0;

    private:
        ProximityStrategy(const ProximityStrategy&);
        ProximityStrategy& operator=(const ProximityStrategy&);

        rw::kinematics::FrameMap<ProximityModelPtr> _frameToModel;

    protected:



        ProximityStrategy();
    };


}}
# 30 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp" 2

namespace rw { namespace proximity {
# 41 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp"
 struct DistanceResult {

  const kinematics::Frame* f1;


  const kinematics::Frame* f2;




  math::Vector3D<double> p1;


  math::Vector3D<double> p2;


  double distance;


  unsigned int idx1,idx2;
 };






    class DistanceStrategy : public virtual ProximityStrategy {

    public:



        virtual ~DistanceStrategy();
# 97 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/proximity/DistanceStrategy.hpp"
        virtual bool distance(DistanceResult &result,
                              const kinematics::Frame* a,
               const math::Transform3D<>& wTa,
                        const kinematics::Frame* b,
                        const math::Transform3D<>& wTb,
                        double rel_err = 0.0, double abs_err = 0.0);

        virtual bool calcDistance(DistanceResult &result,
                              ProximityModelPtr a,
                              const math::Transform3D<>& wTa,
                              ProximityModelPtr b,
                              const math::Transform3D<>& wTb,
                              double rel_err = 0.0, double abs_err = 0.0) = 0;

    private:
        DistanceStrategy(const DistanceStrategy&);
        DistanceStrategy& operator=(const DistanceStrategy&);

    protected:



        DistanceStrategy();
    };




    typedef rw::common::Ptr<DistanceStrategy> DistanceStrategyPtr;


}}
# 26 "/home/preben/working/CRTPlanner/DynamicWorkCell.hpp" 2



namespace rw { namespace dynamics {

    class DynamicWorkCell {
    public:
        DynamicWorkCell();
        DynamicWorkCell(rw::models::WorkCellPtr workcell, rw::models::SerialDevicePtr serialDevice);
        virtual ~DynamicWorkCell();

        std::vector<rw::kinematics::Frame*>& getDynamicObstacles() { return _dynamicObstacles; }
        const std::vector<rw::kinematics::Frame*>& getDynamicObstacles() const { return _dynamicObstacles; }

        std::vector<rw::kinematics::Frame*>& getStaticObstacles() { return _staticObstacles; }
        const std::vector<rw::kinematics::Frame*>& getStaticObstacles() const { return _staticObstacles; }

        rw::models::WorkCellPtr getWorkCell() { return _workcell; }

        rw::models::SerialDevicePtr getDevice() { return _serialDevice; }






    protected:
        void initialize();

        rw::models::WorkCellPtr _workcell;
        rw::models::SerialDevicePtr _serialDevice;

        std::vector<rw::kinematics::Frame*> _dynamicObstacles;
        std::vector<rw::kinematics::Frame*> _staticObstacles;




        std::vector<rw::math::Transform3D<double> > _wTs;

    };

} }
# 14 "/home/preben/working/CRTPlanner/CRTPlanner.hpp" 2
# 1 "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp" 1
# 9 "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp"
#define MANIPULATORKINEMATICS_HPP_ 
# 19 "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp"
# 1 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp" 1
# 20 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
#define RW_KINEMATICS_KINEMATICS_HPP 
# 29 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
namespace rw { namespace kinematics {

    class MovableFrame;







    class Kinematics {
    public:
# 52 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static math::Transform3D<> worldTframe(const Frame* to, const State& state);
# 73 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static math::Transform3D<> frameTframe(
            const Frame* from, const Frame* to, const State& state);
# 91 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static std::vector<Frame*> findAllFrames(Frame* root, const State& state);
# 108 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static std::vector<Frame*> findAllFrames(Frame* root);
# 117 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static Frame& worldFrame(Frame& frame, const State& state);
# 126 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static const Frame& worldFrame(const Frame& frame, const State& state);
# 141 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static std::vector<Frame*> childToParentChain(Frame* child,
                                                      Frame* parent,
                                                      const State& state);





        static std::vector<Frame*> reverseChildToParentChain(Frame* child,
                                                             Frame* parent,
                                                             const State& state);
# 160 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static std::vector<Frame*> parentToChildChain(Frame* parent,
                                                      Frame* child,
                                                      const State& state);




        typedef std::map<std::string, kinematics::Frame*> FrameMap;
# 179 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static FrameMap buildFrameMap(kinematics::Frame& root,
                                      const kinematics::State& state);




        static bool isDAF(const Frame& frame);
# 194 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static void gripFrame(State& state, Frame& item, Frame& gripper);





        static State grippedFrame(const State& state, Frame& item, Frame& gripper);
# 211 "/home/preben/working/RobWork-0.5/RobWork/build/../src/rw/kinematics/Kinematics.hpp"
        static void gripMovableFrame(State& state, MovableFrame& item, Frame& gripper);







        static State grippedMovableFrame(
            const State& state, MovableFrame& item, Frame& gripper);
    };


}}
# 20 "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp" 2






namespace rw { namespace dynamics {

    template <typename T = double>
    class ManipulatorKinematics {
    public:
        ManipulatorKinematics() {

        }


        ManipulatorKinematics(const rw::models::SerialDevicePtr sd, const rw::kinematics::State& defaultState) :
            _serialDevice(sd), _defaultState(defaultState) {
            initialize();
        }


        virtual ~ManipulatorKinematics() {

        }


        unsigned int getNoBodies() const {
            return _serialDevice->getDOF();
        }




        const std::vector<math::Transform3D<T> >& worldTdynamic() const {
            return _wTd;
        }

        const rw::math::Transform3D<T>& worldTdynamic(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 59));
            ((i <= _wTd.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _wTd.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 60));

            return _wTd[i-1];
        }

        const std::vector<math::Transform3D<T> > worldTdynamic(const rw::kinematics::State& state) const {
            std::vector<math::Transform3D<T> > wTd;
            wTd.resize(_dynamicFrames.size());

            for (unsigned int i = 0; i < _dynamicFrames.size(); ++i) {
                wTd[i] = rw::kinematics::Kinematics::worldTframe(_dynamicFrames[i], state);
            }

            return wTd;
        }





        const std::vector<math::Transform3D<T> >& worldTlink() const {
            return _wTl;
        }

        const rw::math::Transform3D<T>& worldTlink(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 85));
            ((i <= _wTl.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _wTl.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 86));

            return _wTl[i-1];
        }

        const std::vector<math::Transform3D<T> > worldTlink(const rw::kinematics::State& state) const {
            std::vector<math::Transform3D<T> > wTl;
            const std::vector<rw::models::Joint*>& joints = _serialDevice->getJoints();
            wTl.resize(joints.size());

            for (unsigned int i = 0; i < joints.size(); ++i) {

                const rw::kinematics::Frame* f = (rw::kinematics::Frame*) joints[i];
                wTl[i] = rw::kinematics::Kinematics::worldTframe(f, state);
            }

            return wTl;
        }



        const std::vector<math::Transform3D<T> >& dynamicTlink() const {
            return _dTl;
        }


        const rw::math::Transform3D<T>& dynamicTlink(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 113));
            ((i <= _dTl.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _dTl.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 114));

            return _dTl[i-1];
        }




        const std::vector<math::Transform3D<T> >& linkTdynamic() const {
            return _lTd;
        }

        const rw::math::Transform3D<T>& linkTdynamic(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 127));
            ((i <= _lTd.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _lTd.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 128));

            return _lTd[i-1];
        }



        const rw::math::Transform3D<T>& dynamicTgraphics(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 136));
            ((i <= _dTg.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _dTg.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 137));

            return _dTg[i-1];
        }


        const rw::math::Transform3D<T>& graphicsTdynamic(unsigned int i) const {
            ((i > 0) ? (void)0 : rw::common::IOUtil::rwAssert("i > 0", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 144));
            ((i <= _gTd.size()) ? (void)0 : rw::common::IOUtil::rwAssert("i <= _gTd.size()", "/home/preben/working/CRTPlanner/ManipulatorKinematics.hpp", 145));

            return _gTd[i-1];
        }



        boost::numeric::ublas::vector<T>& getMass() {
            return _mass;
        }


        const boost::numeric::ublas::vector<T>& getMass() const {
            return _mass;
        }



        rw::math::Q jointValues(const std::vector<rw::math::Transform3D<T> >& wTd) const {
            rw::math::Q q(boost::numeric::ublas::zero_vector<T>(_serialDevice->getDOF()));

            rw::kinematics::State state = _defaultState;

            const std::vector<rw::models::Joint*>& joints = _serialDevice->getJoints();


            for (unsigned int i = 0; i < q.size(); ++i) {
                _serialDevice->setQ(q, state);
                rw::math::Transform3D<T> t1 = rw::kinematics::Kinematics::worldTframe(static_cast<const rw::kinematics::Frame*>(joints[i]), state);
                rw::math::Transform3D<T> t2 = wTd[i] * _dTl[i];

                rw::math::Vector3D<T> x1(column(t1.R().m(), 0));
                rw::math::Vector3D<T> x2(column(t2.R().m(), 0));
                rw::math::Vector3D<T> z(column(t1.R().m(), 2));
                q(i) = toJointValue(x1, x2, z);
            }

            return q;



        }





    protected:
        void initialize() {
            const std::vector<rw::models::Joint*>& joints = _serialDevice->getJoints();
            const int dof = _serialDevice->getDOF();


            _wTd.resize(dof);
            _lTd.resize(dof);
            _dTl.resize(dof);
            _dTg.resize(dof);
            _gTd.resize(dof);
            _mass.resize(12*dof);
            _dynamicFrames.resize(dof);



            _wTl = worldTlink(_defaultState);


            for (unsigned int i = 0; i < joints.size(); ++i) {
                rw::kinematics::Frame::const_iterator_pair iters = ((const rw::kinematics::Frame* )joints[i])->getChildren();
                rw::kinematics::Frame::const_iterator it = iters.first;
                for (; it != iters.second; ++it) {
                    const rw::common::PropertyMap& prop = it->getPropertyMap();
                    if (prop.has("dynamic")) {
                        _dynamicFrames[i] = &(*it);
                        break;
                    }
                }

                if (it == iters.second)
                    std::cerr << "Joint (" << i << ") have no dynamic frame" << std::endl;
            }



            for (unsigned int i = 0; i < _dynamicFrames.size(); ++i) {
                _wTd[i] = rw::kinematics::Kinematics::worldTframe(_dynamicFrames[i], _defaultState);
                _lTd[i] = _dynamicFrames[i]->getTransform(_defaultState);
                _dTl[i] = rw::math::inverse(_dynamicFrames[i]->getTransform(_defaultState));
            }


            for (unsigned int i = 0; i < _dynamicFrames.size(); ++i) {
                const rw::common::PropertyMap& prop = _dynamicFrames[i]->getPropertyMap();

                if (prop.has("mass")) {
                    std::istringstream mass(prop.get<std::string>("mass"));

                    double m0, m1, m2, m3;
                    mass >> m0; mass >> m1; mass >> m2; mass >> m3;

                    _mass(12*i + 0) = m0; _mass(12*i + 1) = m0; _mass(12*i + 2) = m0;
                    _mass(12*i + 3) = m1; _mass(12*i + 4) = m1; _mass(12*i + 5) = m1;
                    _mass(12*i + 6) = m2; _mass(12*i + 7) = m2; _mass(12*i + 8) = m2;
                    _mass(12*i + 9) = m3; _mass(12*i + 10) = m3; _mass(12*i + 11) = m3;
                }

            }



        }


        double toJointValue(const rw::math::Vector3D<T>& x1, const rw::math::Vector3D<T>& x2, const rw::math::Vector3D<T>& z) const {
            T dotp = dot(normalize(x1), normalize(x2));
            T angle;

            if (dotp > 1)
                angle = 0;
            else
                angle = acos(dotp);

            if (isnan(angle)) {
                std::cout << "x1: " << x1 << std::endl << "x2: " << x2 << std::endl;
                std::cout << "dot product: " << dot(normalize(x1), normalize(x2));
                throw 0;
            }

            rw::math::Vector3D<T> axis = cross(x1, x2);

            if (axis.norm2() > 0.0001) {
                rw::math::Vector3D<T> diff = z - normalize(axis);
                if (diff.norm2() > 0.5)
                    angle = -angle;
            }

            return angle;
        }



        const rw::models::SerialDevicePtr _serialDevice;
        rw::kinematics::State _defaultState;


        std::vector<const rw::kinematics::Frame*> _dynamicFrames;


        std::vector<rw::math::Transform3D<T> > _wTd;
        std::vector<rw::math::Transform3D<T> > _wTl;


        std::vector<rw::math::Transform3D<T> > _lTd;
        std::vector<rw::math::Transform3D<T> > _dTl;


        std::vector<rw::math::Transform3D<T> > _dTg;
        std::vector<rw::math::Transform3D<T> > _gTd;


        boost::numeric::ublas::vector<T> _mass;
    };

} }
# 15 "/home/preben/working/CRTPlanner/CRTPlanner.hpp" 2
# 1 "/home/preben/working/CRTPlanner/ManipulatorScene.hpp" 1
# 9 "/home/preben/working/CRTPlanner/ManipulatorScene.hpp"
#define RW_DYNAMICS_MANIPULATORSCENE_HPP_ 




# 1 "/home/preben/working/CRTPlanner/Manipulator.hpp" 1
# 9 "/home/preben/working/CRTPlanner/Manipulator.hpp"
#define MANIPULATOR_HPP_ 




# 1 "/home/preben/working/CRTPlanner/Potential.hpp" 1

#define POTENTIAL_HPP_ 



namespace rw { namespace dynamics {

    template <typename T = double>
    class Potential {
    public:
        Potential() { };
        virtual ~Potential() { };

        virtual double potential(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const = 0;
        virtual boost::numeric::ublas::vector<double> dPotential(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const = 0;
    };

} }
# 15 "/home/preben/working/CRTPlanner/Manipulator.hpp" 2
# 1 "/home/preben/working/CRTPlanner/RigidBody.hpp" 1
# 9 "/home/preben/working/CRTPlanner/RigidBody.hpp"
#define RIGIDBODY_HPP 



# 1 "/home/preben/working/CRTPlanner/ConstraintOrthonormal.hpp" 1
# 9 "/home/preben/working/CRTPlanner/ConstraintOrthonormal.hpp"
#define CONSTRAINTORTHONORMAL_HPP_ 




# 1 "/home/preben/working/CRTPlanner/DynamicFrame.hpp" 1
# 9 "/home/preben/working/CRTPlanner/DynamicFrame.hpp"
#define DYNAMICFRAME_HPP_ 
# 22 "/home/preben/working/CRTPlanner/DynamicFrame.hpp"
namespace rw { namespace dynamics {

    template <typename T = double>
    class DynamicFrame {
    public:
        DynamicFrame() {
        }


        DynamicFrame(unsigned int offset) :
            _offset(offset) {
        }





        unsigned int offset() const {
            return _offset;
        }






        math::Vector3D<T> R(const boost::numeric::ublas::vector<double>& q) const {
            return Rn(_offset, q);
        }





        math::Vector3D<T> dRn(const boost::numeric::ublas::vector<double>& q, unsigned int variable) const {
            return dRn(_offset, variable, q);
        }





        math::Vector3D<T> Une(const boost::numeric::ublas::vector<double>& q, unsigned int e) const {
            return Une(_offset, e, q);
        }





        math::Vector3D<T> dUne(const boost::numeric::ublas::vector<double>& q, unsigned int e, unsigned int variable) const {
            return dUne(_offset, e, variable, q);
        }






        void toCoordinates(const boost::numeric::ublas::vector<double>& q, const math::Transform3D<T>& wTf) {
            toCoordinates(_offset, wTf, q);
        }





        math::Transform3D<T> toTransform3D(const boost::numeric::ublas::vector<double>& q) {
            return toTransform3D(_offset, q);
        }
# 102 "/home/preben/working/CRTPlanner/DynamicFrame.hpp"
        inline static void toCoordinates(int offset, const rw::math::Transform3D<T>& t, boost::numeric::ublas::vector<T>& q) {
            const rw::math::Vector3D<T>& pos = t.P();
            const rw::math::Rotation3D<T>& rot = t.R();

            for (unsigned int i = 1; i <= 3; ++i) {
                q(offset + i - 1) = pos(i-1);
                for (unsigned int e = 1; e <= 3; ++e) {
                    q(offset + 3*e + i - 1) = rot(i-1,e-1);
                }
            }
        }






        inline static rw::math::Transform3D<T> toTransform3D(int offset, const boost::numeric::ublas::vector<T>& q) {
            ((q.size() > offset) ? (void)0 : rw::common::IOUtil::rwAssert("q.size() > offset", "/home/preben/working/CRTPlanner/DynamicFrame.hpp", 120));

            rw::math::Transform3D<T> t;
            rw::math::Vector3D<T>& pos = t.P();
            rw::math::Rotation3D<T>& rot = t.R();

            pos = rw::math::Vector3D<double> (q[offset + 0], q[offset + 1], q[offset + 2]);
            rot = rw::math::Rotation3D<double>(q[offset + 3], q[offset + 6], q[offset + 9],
                                               q[offset + 4], q[offset + 7], q[offset + 10],
                                               q[offset + 5], q[offset + 8], q[offset + 11]);

            return t;
        }



        inline static math::Vector3D<T> Rn(unsigned int offset, const boost::numeric::ublas::vector<T>& q) {
            rw::math::Vector3D<T> rn;

            rn(0) = q(offset);
            rn(1) = q(offset + 1);
            rn(2) = q(offset + 2);

            return rn;
        }


        inline static math::Vector3D<T> dRn(unsigned int offset, unsigned int variable, const boost::numeric::ublas::vector<T>& q) {
            rw::math::Vector3D<T> rn;

            rn(0) = (offset == variable) ? 1 : 0;
            rn(1) = (offset + 1 == variable) ? 1 : 0;
            rn(2) = (offset + 2 == variable) ? 1 : 0;

            return rn;
        }


        inline static math::Vector3D<T> Une(unsigned int offset, unsigned int e, const boost::numeric::ublas::vector<T>& q) {
            rw::math::Vector3D<T> une;

            une(0) = q(offset + 3*e);
            une(1) = q(offset + 3*e + 1);
            une(2) = q(offset + 3*e + 2);

            return une;
        }


        inline static math::Vector3D<T> dUne(unsigned int offset, unsigned int e, unsigned int variable, const boost::numeric::ublas::vector<T>& q) {
            rw::math::Vector3D<T> une;

            une(0) = (offset + 3*e == variable) ? 1 : 0;
            une(1) = (offset + 3*e + 1 == variable) ? 1 : 0;
            une(2) = (offset + 3*e + 2 == variable) ? 1 : 0;

            return une;
        }



    protected:

        unsigned int _offset;
    };


} }
# 15 "/home/preben/working/CRTPlanner/ConstraintOrthonormal.hpp" 2
# 25 "/home/preben/working/CRTPlanner/ConstraintOrthonormal.hpp"
namespace rw { namespace dynamics {

 template <typename T = double>
 class ConstraintOrthonormal : public Constraint<T> {
    public:
     ConstraintOrthonormal(const DynamicFrame<T>& frame, unsigned int alpha) :
            Constraint<T>(),
            _frame(frame),
            _alpha(alpha),
            _beta(alpha),
            _length(1.0) {

            const unsigned int offset = _frame.offset();

            for (unsigned int j = 0; j < 3; ++j) {
                this->_depends.push_back(offset + 3*alpha + j);
                this->_coeffs.push_back(1);
            }
     }

        ConstraintOrthonormal(const DynamicFrame<T>& frame, unsigned int alpha, unsigned int beta) :
            Constraint<T>(),
            _frame(frame),
            _alpha(alpha),
            _beta(beta),
            _length(0.0) {

            ((alpha != beta) ? (void)0 : rw::common::IOUtil::rwAssert("alpha != beta", "/home/preben/working/CRTPlanner/ConstraintOrthonormal.hpp", 52));

            unsigned int offset = _frame.offset();

            for (unsigned int j = 0; j < 3; ++j) {

                this->_depends.push_back(offset + 3*alpha + j);
                this->_coeffs.push_back(1);


                this->_depends.push_back(offset + 3*beta + j);
                this->_coeffs.push_back(1);
            }

        }

        ~ConstraintOrthonormal() {};

        virtual T evaluate(const boost::numeric::ublas::vector<T>& q) const {
            T value = math::dot(_frame.Une(q, _alpha), _frame.Une(q, _beta)) - _length;

            if (_alpha == _beta)
                value /= 2;

            return value;
        }

        virtual T dG(unsigned int variable, const boost::numeric::ublas::vector<T>& q) const {
            T value = 0;

            const unsigned int offset = _frame.offset();

            for (unsigned int j = 0; j < 3; ++j) {
                if (offset + 3*_alpha + j == variable) {
                    value = q[offset + 3*_beta + j];
                    break;
                } else if (offset + 3*_beta + j == variable) {
                    value = q[offset + 3*_alpha + j];
                    break;
                }
            }

            return value;
        }

        virtual T ddG(unsigned int variable1, unsigned int variable2, const boost::numeric::ublas::vector<T>& q) const {
            T value = 0.0;
            for (unsigned int j = 0; j < 3; ++j) {
                const unsigned int qi = _frame.offset() + j;
                if ((qi + 3*_alpha == variable1 && qi + 3*_beta == variable2) ||
                    (qi + 3*_alpha == variable2 && qi + 3*_beta == variable1)) {
                    value = 1.0;
                }
            }

            return value;
        }

    protected:
        DynamicFrame<T> _frame;
        unsigned int _alpha;
        unsigned int _beta;
        T _length;
 };

} }
# 14 "/home/preben/working/CRTPlanner/RigidBody.hpp" 2
# 26 "/home/preben/working/CRTPlanner/RigidBody.hpp"
namespace rw { namespace dynamics {

 template <typename T = double>
 class RigidBody : public DynamicFrame<T> {
    public:



     RigidBody() : DynamicFrame<T>() {
     }




        RigidBody(boost::numeric::ublas::vector<T>* m, unsigned int n) :
            DynamicFrame<T>(12*(n-1)), _m(m), _n(n) {

            _constraints.reserve(6);

            for (unsigned int alpha = 1; alpha <= 3; ++alpha) {
                this->_constraints.push_back(new ConstraintOrthonormal<T>(*this, alpha));
                for (unsigned int beta = alpha+1; beta <= 3; ++beta) {
                    this->_constraints.push_back(new ConstraintOrthonormal<T>(*this, alpha, beta));
                }
            }
        }





        RigidBody(const RigidBody<T>& body) :
            DynamicFrame<T>(body), _m(body._m), _n(body._n), _constraints(body._constraints) {
        }




        ~RigidBody() {
        }





        std::vector<Constraint<T>* >& constraints() {
            return _constraints;
        }





        const std::vector<Constraint<T>* >& constraints() const {
            return _constraints;
        }







    protected:
        boost::numeric::ublas::vector<T>* _m;
        unsigned int _n;

        std::vector<Constraint<T>* > _constraints;
 };

} }
# 16 "/home/preben/working/CRTPlanner/Manipulator.hpp" 2


namespace rw { namespace dynamics {
# 32 "/home/preben/working/CRTPlanner/Manipulator.hpp"
    class Manipulator : public MechSystem<double> {
    public:




        Manipulator(const ManipulatorKinematics<double>& mpKinematics);







        virtual ~Manipulator();







        virtual double V(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const;
        virtual boost::numeric::ublas::vector<double> dV(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const;

        void setInitialPosition(const std::vector<math::Transform3D<double> >& dynamics);




        boost::numeric::ublas::vector<double> toCoordinates(const std::vector<math::Transform3D<double> >& dynamics) const;

    protected:
        std::vector<math::Transform3D<double> > toFrames(const boost::numeric::ublas::vector<double>& q) const;


        unsigned int indexL(unsigned int v, unsigned int k) { return 9 + v - k; }
        unsigned int indexJ(unsigned int alpha, unsigned int beta) { return alpha + beta - 1 + (static_cast<unsigned int>(std::min(alpha, beta) / 2)); }

        void initConstraints();





        unsigned int _bodies;



        boost::numeric::ublas::vector<double> q0;

        ManipulatorKinematics<double> _mpKinematics;
    };


} }
# 15 "/home/preben/working/CRTPlanner/ManipulatorScene.hpp" 2
# 31 "/home/preben/working/CRTPlanner/ManipulatorScene.hpp"
namespace rw { namespace dynamics {

    class ManipulatorScene : public Manipulator {
    public:
        ManipulatorScene();
        ManipulatorScene(const DynamicWorkCell& workcell, const ManipulatorKinematics<double>& kinematics);
        virtual ~ManipulatorScene();


        virtual double V(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const;
        virtual boost::numeric::ublas::vector<double> dV(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const;


    protected:
        void initialize();
# 54 "/home/preben/working/CRTPlanner/ManipulatorScene.hpp"
        DynamicWorkCell _dynamicWorkCell;
        rw::models::WorkCellPtr _workcell;
        rw::models::SerialDevicePtr _serialDevice;
        ManipulatorKinematics<double> _mpKinematics;
    };

} }
# 16 "/home/preben/working/CRTPlanner/CRTPlanner.hpp" 2
# 30 "/home/preben/working/CRTPlanner/CRTPlanner.hpp"
namespace rw { namespace dynamics {


    class CRTPlanner {
    public:
        CRTPlanner(rw::models::WorkCellPtr, rw::models::SerialDevicePtr device);

        void setStart(const rw::math::Q& q) { _qinit = q; }
        void setGoal(const rw::math::Q& q) { _qend = q; }

        void plan();


    protected:
        rw::models::WorkCellPtr _workcell;
        rw::models::SerialDevicePtr _device;

        DynamicWorkCell _dWorkcell;
        ManipulatorKinematics<double> _mpKinematics;
        ManipulatorScene _mpScene;


        rw::math::Q _qinit;
        rw::math::Q _qend;
    };


} }
# 11 "/home/preben/working/CRTPlanner/CRTPlanner.cpp" 2



# 1 "/home/preben/working/CRTPlanner/MechComputer.hpp" 1

#define MECH_COMPUTER_HPP_ 
# 18 "/home/preben/working/CRTPlanner/MechComputer.hpp"
namespace rw { namespace dynamics {
# 33 "/home/preben/working/CRTPlanner/MechComputer.hpp"
    class MechComputer {
    public:




        MechComputer(const MechSystem<double>& msystem,
                     const boost::numeric::ublas::vector<double>& q0,
                     const boost::numeric::ublas::vector<double>& v0);






        virtual ~MechComputer();


        void initFirstStep();
        void saveStep();
        const boost::numeric::ublas::vector<double>& step(double h, bool correction);
        const boost::numeric::ublas::vector<double>& step(double h, bool first, bool correction);
        const boost::numeric::ublas::vector<double>& stepVV(double h, bool first, bool correction);
        const boost::numeric::ublas::vector<double>& stepVV2(double h, bool first, bool correction);
        const boost::numeric::ublas::vector<double>& stepVerletGordon(double h, bool first, bool correction);
        const boost::numeric::ublas::vector<double>& stepBeeman(double h, bool first, bool correction);
        const boost::numeric::ublas::vector<double>& stepAB(double h, unsigned int iteration, bool correction);
        const boost::numeric::ublas::vector<double>& stepAB3(double h, unsigned int iteration, bool correction);
        const boost::numeric::ublas::vector<double>& stepRK2(double h, bool correction);
        const boost::numeric::ublas::vector<double>& stepRK4(double h, bool correction);
        const boost::numeric::ublas::vector<double>& simulate(double h = 0.01, double time = 1.0);

        void reduceVelocity(double alpha);
        void backStep();

        double kineticEnergy() const;

        const boost::numeric::ublas::vector<double>& getQ() const { return _q; };
        const boost::numeric::ublas::vector<double>& getV() const { return _v; };
        const boost::numeric::ublas::vector<double> getA() const { return calcAcceleration(_q, _v); }


    protected:
        inline boost::numeric::ublas::vector<double> calcAcceleration(const boost::numeric::ublas::vector<double>& q, const boost::numeric::ublas::vector<double>& v) const;
        inline boost::numeric::ublas::vector<double> calcAccelerationNoCFM(const boost::numeric::ublas::vector<double>& q);

        boost::numeric::ublas::matrix<double> M(const boost::numeric::ublas::compressed_matrix<double>& dG,
                                                const boost::numeric::ublas::vector<double>& m) const;

        boost::numeric::ublas::vector<double> mFmT(const boost::numeric::ublas::compressed_matrix<double>& dG,
                                                   const std::vector<boost::numeric::ublas::matrix<double> >& ddG,
                                                   const boost::numeric::ublas::vector<double>& dV,
                                                   const boost::numeric::ublas::vector<double>& v,
                                                   const boost::numeric::ublas::vector<double>& m) const;

        boost::numeric::ublas::vector<double> acceleration(const boost::numeric::ublas::vector<double>& m,
                                                           const boost::numeric::ublas::vector<double>& mu,
                                                           const boost::numeric::ublas::compressed_matrix<double>& dG,
                                                           const boost::numeric::ublas::vector<double>& dV) const;

        boost::numeric::ublas::vector<double> acceleration_no_cfm(const boost::numeric::ublas::vector<double>& m,
                                                           const boost::numeric::ublas::vector<double>& dV);

        boost::numeric::ublas::vector<double> eulerStep(const boost::numeric::ublas::vector<double>& q,
                                                        const boost::numeric::ublas::vector<double>& v,
                                                        double h);


        std::pair<boost::numeric::ublas::vector<double>, boost::numeric::ublas::vector<double> >
        velocityVerletStep(const boost::numeric::ublas::vector<double>& qnm1,
                           const boost::numeric::ublas::vector<double>& qn,
                           const boost::numeric::ublas::vector<double>& vnm1,
                           const boost::numeric::ublas::vector<double>& vn,
                           const boost::numeric::ublas::vector<double>& a,
                           double h);


        void constraintCorrection(const boost::numeric::ublas::vector<double>& m,
                                  boost::numeric::ublas::vector<double>& q,
                                  boost::numeric::ublas::vector<double>& v,
                                  double qerror = 1e-15,
                                  double verror = 1e-14,
                                  unsigned int limit = 20);

        void correctCoordinates(boost::numeric::ublas::matrix<double, boost::numeric::ublas::column_major>& M,
                                const boost::numeric::ublas::vector<double>& G,
                                const boost::numeric::ublas::compressed_matrix<double>& dG,
                                const boost::numeric::ublas::vector<double>& dGv,
                                const boost::numeric::ublas::vector<double>& m,
                                boost::numeric::ublas::vector<double>& q,
                                boost::numeric::ublas::vector<double>& v);

        boost::numeric::ublas::vector<double> calc_dGv(const boost::numeric::ublas::compressed_matrix<double>& dG,
                                                       const boost::numeric::ublas::vector<double>& v);

        boost::numeric::ublas::matrix<double> toMatrix(const boost::numeric::ublas::vector<double>& vec);



        const MechSystem<double> &_system;
        boost::numeric::ublas::vector<double> _q;
        boost::numeric::ublas::vector<double> _v;
        boost::numeric::ublas::vector<double> _a;

        std::vector<boost::numeric::ublas::vector<double> > _qstep;
        std::vector<boost::numeric::ublas::vector<double> > _vstep;
        std::vector<boost::numeric::ublas::vector<double> > _astep;

        boost::numeric::ublas::vector<double> prev;
        boost::numeric::ublas::vector<double> preq;
    };

} }
# 15 "/home/preben/working/CRTPlanner/CRTPlanner.cpp" 2



using namespace rw::kinematics;
using namespace rw::math;
using namespace rw::models;

namespace ublas = boost::numeric::ublas;


namespace rw { namespace dynamics {

    CRTPlanner::CRTPlanner(WorkCellPtr workcell, SerialDevicePtr device) :
        _workcell(workcell),
        _device(device),
        _dWorkcell(workcell, device),
        _mpKinematics(_device, _workcell->getDefaultState()),
        _mpScene(_dWorkcell, _mpKinematics)
        {



    }



    void CRTPlanner::plan() {

        State initState = _workcell->getDefaultState();
        State goalState = initState;

        _device->setQ(_qinit, initState);


        ublas::vector<double> q0 = _mpScene.toCoordinates(_mpKinematics.worldTdynamic(initState));
        ublas::vector<double> v0 = _mpScene.initialVelocities();


        MechComputer computer(_mpScene, q0, v0);


        std::cout << "Epot          :    " << _mpScene.V(q0, v0) << std::endl;
        std::cout << "Constraints   :    " << _mpScene.constraintError(q0) << std::endl;


        std::cout << "mass          :    " << _mpScene.getMass() << std::endl;

        double h = 0.005;
        boost::numeric::ublas::vector<double> q = computer.stepBeeman(h, true, true);;
        boost::numeric::ublas::vector<double> v = computer.getV();

        double last = 0;

        std::cout << "  t  |  cerr  |  Ekin  |  Epot  |  Etot  |  Eerr  " << std::endl;
        for (unsigned int i = 0; i < 500; ++i) {
            double kin = computer.kineticEnergy();
            double pot = _mpScene.V(q, v);
            double cerr = norm_2(_mpScene.constraints(q));

            std::cout << (i+1)*h << "   " << cerr << "   " << kin << "   " << pot << "   " << kin+pot << "   " << last - (kin+pot) << std::endl;
            q = computer.stepBeeman(h, false, true);
            v = computer.getV();
            last = kin+pot;
        }
    }
# 132 "/home/preben/working/CRTPlanner/CRTPlanner.cpp"
} }